(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:basename) op:Equal rhs:{(DQ ("s,^.*/,,g"))} spids:[76])]
      spids: [76]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:progpath)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$0"))}
          spids: [97]
        )
      ]
      spids: [97]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:progname)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(DQ ($ VSub_Name "$progpath"))})
                          (C {($ VSub_Name "$SED")} {($ VSub_Name "$basename")})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [107 119]
              )
            }
          spids: [106]
        )
      ]
      spids: [106]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:modename)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$progname"))}
          spids: [121]
        )
      ]
      spids: [121]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:EXIT_SUCCESS) op:Equal rhs:{(0)} spids:[130])]
      spids: [130]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:EXIT_FAILURE) op:Equal rhs:{(1)} spids:[133])]
      spids: [133]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:PROGRAM) op:Equal rhs:{(ltmain.sh)} spids:[137])]
      spids: [137]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:PACKAGE) op:Equal rhs:{(libtool)} spids:[140])]
      spids: [140]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:VERSION) op:Equal rhs:{(1.5.22)} spids:[143])]
      spids: [143]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TIMESTAMP)
          op: Equal
          rhs: {(DQ (" (1.1220.2.365 2005/12/18 22:14:06)"))}
          spids: [146]
        )
      ]
      spids: [146]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} {(-n)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name ZSH_VERSION>
                        suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(set)})
                        spids: [165 169]
                      )
                    )
                  }
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(setopt)} {(NO_GLOB_SUBST)})]
          spids: [-1 174]
        )
      ]
      spids: [-1 181]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(DQ (X) ($ VSub_Number "$1"))} {(Lit_Other "=")} {(X--no-reexec)})
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(shift)})]
          spids: [-1 201]
        )
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} {(DQ (X) ($ VSub_Number "$1"))} {(Lit_Other "=")} {(X--fallback-echo)})
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(Lit_Other ":")})]
          spids: [210 224]
        )
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} 
                  {
                    (DQ (X) 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Subshell
                                child: (C {($ VSub_Name "$echo")} {(SQ <"\\t">)})
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [248]
                                  )
                                ]
                                spids: [240 246]
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [239 250]
                      )
                    )
                  } {(Lit_Other "=")} {(SQ <"X\\t">)}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(Lit_Other ":")})]
          spids: [233 260]
        )
      ]
      else_action: [
        (C {(exec)} {($ VSub_Name "$SHELL")} {(DQ ($ VSub_Name "$progpath"))} {(--no-reexec)} 
          {
            (BracedVarSub
              token: <VSub_Number 1>
              suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At "$@"))})
              spids: [286 292]
            )
          }
        )
      ]
      spids: [269 294]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} {(DQ (X) ($ VSub_Number "$1"))} {(Lit_Other "=")} {(X--fallback-echo)})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(shift)})
            (SimpleCommand
              words: [{(cat)}]
              redirects: [
                (HereDoc
                  op_id: Redir_DLess
                  fd: -1
                  body: {(DQ ($ VSub_Star "$*") ("\n"))}
                  do_expansion: True
                  here_end: EOF
                  was_filled: True
                  spids: [323]
                )
              ]
            )
            (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
          ]
          spids: [-1 311]
        )
      ]
      spids: [-1 333]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:default_mode) op:Equal rhs:{(SQ )} spids:[336])]
      spids: [336]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:help)
          op: Equal
          rhs: 
            {
              (DQ ("Try ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$progname") 
                (" --help' for more information.")
              )
            }
          spids: [338]
        )
      ]
      spids: [338]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:magic)
          op: Equal
          rhs: {(DQ ("%%%MAGIC variable%%%"))}
          spids: [346]
        )
      ]
      spids: [346]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:mkdir) op:Equal rhs:{(DQ (mkdir))} spids:[351])]
      spids: [351]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:mv) op:Equal rhs:{(DQ ("mv -f"))} spids:[356])]
      spids: [356]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:rm) op:Equal rhs:{(DQ ("rm -f"))} spids:[361])]
      spids: [361]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:Xsed)
          op: Equal
          rhs: {(DQ (${ VSub_Name SED)) (SQ <" -e 1s/^X//">)}
          spids: [373]
        )
      ]
      spids: [373]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:sed_quote_subst)
          op: Equal
          rhs: {(SQ <"s/\\([\\\\`\\\\\"$\\\\\\\\]\\)/\\\\\\1/g">)}
          spids: [383]
        )
      ]
      spids: [383]
    )
    (Case
      to_match: 
        {
          (CommandSubPart
            command_list: 
              (CommandList
                children: [
                  (Pipeline
                    children: [(C {(echo)} {(X)}) (C {(tr)} {(X)} {(SQ <"\\101">)})]
                    negated: False
                  )
                ]
              )
            left_token: <Left_Backtick "`">
            spids: [393 405]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(A)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SP2NL)
                  op: Equal
                  rhs: {(SQ <"tr \\040 \\012">)}
                  spids: [421]
                )
              ]
              spids: [421]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NL2SP)
                  op: Equal
                  rhs: {(SQ <"tr \\015\\012 \\040\\040">)}
                  spids: [427]
                )
              ]
              spids: [427]
            )
          ]
          spids: [410 411 433 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SP2NL)
                  op: Equal
                  rhs: {(SQ <"tr \\100 \\n">)}
                  spids: [443]
                )
              ]
              spids: [443]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NL2SP)
                  op: Equal
                  rhs: {(SQ <"tr \\r\\n \\100\\100">)}
                  spids: [449]
                )
              ]
              spids: [449]
            )
          ]
          spids: [436 437 455 -1]
        )
      ]
      spids: [391 407 457]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name LC_ALL>
                        suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(set)})
                        spids: [480 484]
                      )
                    )
                  } {(Lit_Other "=")} {(set)}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:save_LC_ALL)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$LC_ALL"))}
                      spids: [495]
                    )
                  ]
                  spids: [495]
                )
              terminator: <Op_Semi ";">
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:LC_ALL) op:Equal rhs:{(C)} spids:[501])]
                  spids: [501]
                )
              terminator: <Op_Semi ";">
            )
            (C {(export)} {(LC_ALL)})
          ]
          spids: [-1 492]
        )
      ]
      spids: [-1 509]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(test)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name LANG>
                        suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(set)})
                        spids: [516 520]
                      )
                    )
                  } {(Lit_Other "=")} {(set)}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:save_LANG)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$LANG"))}
                      spids: [531]
                    )
                  ]
                  spids: [531]
                )
              terminator: <Op_Semi ";">
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:LANG) op:Equal rhs:{(C)} spids:[537])]
                  spids: [537]
                )
              terminator: <Op_Semi ";">
            )
            (C {(export)} {(LANG)})
          ]
          spids: [-1 528]
        )
      ]
      spids: [-1 545]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:lt_nl) op:Equal rhs:{(SQ <"\n">)} spids:[551])]
      spids: [551]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:IFS)
          op: Equal
          rhs: {(DQ (" \t") ($ VSub_Name "$lt_nl"))}
          spids: [556]
        )
      ]
      spids: [556]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (AndOr
                  children: [
                    (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                      {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                    )
                    (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} {(KW_Bang "!") (Lit_Other "=")} 
                      {(yes)}
                    )
                  ]
                  op_id: Op_DAmp
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {($ VSub_Name "$echo")}
                {(DQ ($ VSub_Name "$modename") (": not configured to build any kind of library"))}
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[600])]
            )
            (SimpleCommand
              words: [
                {($ VSub_Name "$echo")}
                {
                  (DQ ("Fatal configuration error.  See the ") ($ VSub_Name "$PACKAGE") 
                    (" docs for more information.")
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[612])]
            )
            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
          ]
          spids: [-1 590]
        )
      ]
      spids: [-1 620]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:mode)
          op: Equal
          rhs: {($ VSub_Name "$default_mode")}
          spids: [626]
        )
      ]
      spids: [626]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:nonopt) op:Equal rhs:{(SQ )} spids:[629])]
      spids: [629]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:prev) op:Equal rhs:{(SQ )} spids:[631])]
      spids: [631]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:prevopt) op:Equal rhs:{(SQ )} spids:[633])]
      spids: [633]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:run) op:Equal rhs:{(SQ )} spids:[635])]
      spids: [635]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:show)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$echo"))}
          spids: [637]
        )
      ]
      spids: [637]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:show_help) op:Equal rhs:{(SQ )} spids:[642])]
      spids: [642]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:execute_dlfiles) op:Equal rhs:{(SQ )} spids:[644])]
      spids: [644]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:duplicate_deps) op:Equal rhs:{(no)} spids:[646])]
      spids: [646]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:preserve_args) op:Equal rhs:{(SQ )} spids:[649])]
      spids: [649]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:lo2o)
          op: Equal
          rhs: 
            {
              (DQ (s/) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (.lo) 
                (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (/.) (${ VSub_Name objext) (/)
              )
            }
          spids: [651]
        )
      ]
      spids: [651]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:o2lo)
          op: Equal
          rhs: 
            {
              (DQ (s/) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (.) (${ VSub_Name objext) 
                (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (/.lo/)
              )
            }
          spids: [664]
        )
      ]
      spids: [664]
    )
    (FuncDef
      name: func_mktempdir
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:my_template)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name TMPDIR>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(Lit_Slash /) (tmp)})
                          spids: [709 714]
                        ) (/) 
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: 
                            (StringUnary
                              op_id: VTest_Hyphen
                              arg_word: {($ VSub_Name "$progname")}
                            )
                          spids: [716 720]
                        )
                      )
                    }
                  spids: [707]
                )
              ]
              spids: [707]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(DQ ($ VSub_Name "$run"))} {(Lit_Other "=")} {(DQ (":"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:my_tmpdir)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name my_template) (-) ($ VSub_Dollar "$$"))}
                          spids: [747]
                        )
                      ]
                      spids: [747]
                    )
                  ]
                  spids: [-1 740]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:my_tmpdir)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(mktemp)}
                                      {(-d)}
                                      {(DQ (${ VSub_Name my_template) (-XXXXXXXX))}
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [778]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [766 780]
                          )
                        }
                      spids: [765]
                    )
                  ]
                  spids: [765]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: (C {(test)} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$my_tmpdir"))})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:my_tmpdir)
                              op: Equal
                              rhs: 
                                {
                                  (DQ (${ VSub_Name my_template) (-) 
                                    (BracedVarSub
                                      token: <VSub_Name RANDOM>
                                      suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                                      spids: [810 814]
                                    ) ($ VSub_Dollar "$$")
                                  )
                                }
                              spids: [804]
                            )
                          ]
                          spids: [804]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:save_mktempdir_umask)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: (CommandList children:[(C {(umask)})])
                                    left_token: <Left_Backtick "`">
                                    spids: [821 823]
                                  )
                                }
                              spids: [820]
                            )
                          ]
                          spids: [820]
                        )
                        (C {(umask)} {(0077)})
                        (C {($ VSub_Name "$mkdir")} {(DQ ($ VSub_Name "$my_tmpdir"))})
                        (C {(umask)} {($ VSub_Name "$save_mktempdir_umask")})
                      ]
                      spids: [-1 797]
                    )
                  ]
                  spids: [-1 843]
                )
                (AndOr
                  children: [
                    (C {(test)} {(-d)} {(DQ ($ VSub_Name "$my_tmpdir"))})
                    (BraceGroup
                      children: [
                        (SimpleCommand
                          words: [
                            {($ VSub_Name "$echo")}
                            {
                              (DQ ("cannot create temporary directory ") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\`">
                                ) ($ VSub_Name "$my_tmpdir") ("'")
                              )
                            }
                          ]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[873])]
                        )
                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                      ]
                      spids: [861]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [757 885]
            )
            (Pipeline
              children: [
                (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$my_tmpdir"))})
                (C {($ VSub_Name "$Xsed")})
              ]
              negated: False
            )
          ]
          spids: [704]
        )
      spids: [699 703]
    )
    (FuncDef
      name: func_win32_libid
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:win32_libid_type)
                  op: Equal
                  rhs: {(DQ (unknown))}
                  spids: [930]
                )
              ]
              spids: [930]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:win32_fileres)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(file)} {(-L)} {($ VSub_Number "$1")}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [944]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [937 946]
                      )
                    }
                  spids: [936]
                )
              ]
              spids: [936]
            )
            (Case
              to_match: {($ VSub_Name "$win32_fileres")}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other "*") (ar) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (archive) 
                      (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (import) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (library) (Lit_Other "*")
                    }
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:win32_libid_type)
                          op: Equal
                          rhs: {(DQ ("x86 archive import"))}
                          spids: [971]
                        )
                      ]
                      spids: [971]
                    )
                  ]
                  spids: [956 965 977 -1]
                )
                (case_arm
                  pat_list: [
                    {(Lit_Other "*") (ar) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (archive) 
                      (Lit_Other "*")
                    }
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (Pipeline
                                  children: [
                                    (C {(eval)} {($ VSub_Name "$OBJDUMP")} {(-f)} {($ VSub_Number "$1")})
                                    (SimpleCommand
                                      words: [{($ VSub_Name "$SED")} {(-e)} {(SQ <10q>)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                          spids: [1011]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$EGREP")}
                                        {(-e)}
                                        {(SQ <"file format pe-i386(.*architecture: i386)?">)}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [1026]
                                        )
                                      ]
                                    )
                                  ]
                                  negated: False
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:win32_nmres)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {(eval)} {($ VSub_Name "$NM")} {(-f)} {(posix)} 
                                                    {(-A)} {($ VSub_Number "$1")}
                                                  )
                                                  (C {($ VSub_Name "$SED")} {(-n)} {(-e)} 
                                                    {(SQ <"1,100{/ I /{s,.*,import,;p;q;};}">)}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [1035 1061]
                                      )
                                    }
                                  spids: [1034]
                                )
                              ]
                              spids: [1034]
                            )
                            (Case
                              to_match: {($ VSub_Name "$win32_nmres")}
                              arms: [
                                (case_arm
                                  pat_list: [{(import) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:win32_libid_type)
                                          op: Equal
                                          rhs: {(DQ ("x86 archive import"))}
                                          spids: [1075]
                                        )
                                      ]
                                      spids: [1075]
                                    )
                                  ]
                                  spids: [1071 1073 1079 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:win32_libid_type)
                                          op: Equal
                                          rhs: {(DQ ("x86 archive static"))}
                                          spids: [1085]
                                        )
                                      ]
                                      spids: [1085]
                                    )
                                  ]
                                  spids: [1082 1083 1089 -1]
                                )
                              ]
                              spids: [1064 1068 1092]
                            )
                          ]
                          spids: [-1 1031]
                        )
                      ]
                      spids: [-1 1095]
                    )
                  ]
                  spids: [980 985 1098 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*") (DLL) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:win32_libid_type)
                          op: Equal
                          rhs: {(DQ ("x86 DLL"))}
                          spids: [1107]
                        )
                      ]
                      spids: [1107]
                    )
                  ]
                  spids: [1101 1104 1113 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*") (executable) (Lit_Other "*")}]
                  action: [
                    (Case
                      to_match: {($ VSub_Name "$win32_fileres")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (MS) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) 
                              (Windows) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (PE) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\ ">
                              ) (Intel) (Lit_Other "*")
                            }
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:win32_libid_type)
                                  op: Equal
                                  rhs: {(DQ ("x86 DLL"))}
                                  spids: [1144]
                                )
                              ]
                              spids: [1144]
                            )
                          ]
                          spids: [1132 1141 1150 -1]
                        )
                      ]
                      spids: [1125 1129 1153]
                    )
                  ]
                  spids: [1116 1119 1156 -1]
                )
              ]
              spids: [949 953 1159]
            )
            (C {($ VSub_Name "$echo")} {($ VSub_Name "$win32_libid_type")})
          ]
          spids: [927]
        )
      spids: [922 926]
    )
    (FuncDef
      name: func_infer_tag
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$available_tags"))})
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$tagname"))})
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:CC_quoted)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1220]
                        )
                      ]
                      spids: [1220]
                    )
                    (ForEach
                      iter_name: arg
                      iter_words: [{($ VSub_Name "$CC")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\[">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\^">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\(">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\}">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\<">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\'">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                    {(DQ )}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              )
                                            }
                                          spids: [1274]
                                        )
                                      ]
                                      spids: [1274]
                                    )
                                  ]
                                  spids: [1242 1271 1282 -1]
                                )
                              ]
                              spids: [1235 1239 1285]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:CC_quoted)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$CC_quoted") (" ") ($ VSub_Name "$arg"))}
                                  spids: [1288]
                                )
                              ]
                              spids: [1288]
                            )
                          ]
                          spids: [1232 1296]
                        )
                      spids: [1228 1230]
                    )
                    (Case
                      to_match: {($ VSub_At "$@")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ (" ") ($ VSub_Name "$CC") (" ")) (Lit_Other "*")}
                            {(DQ ($ VSub_Name "$CC") (" ")) (Lit_Other "*")}
                            {
                              (DQ (" ") 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {($ VSub_Name "$echo")} {($ VSub_Name "$CC")})]
                                    )
                                  left_token: <Left_Backtick "`">
                                  spids: [1333 1337]
                                ) (" ")
                              ) (Lit_Other "*")
                            }
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {($ VSub_Name "$echo")} {($ VSub_Name "$CC")})]
                                    )
                                  left_token: <Left_Backtick "`">
                                  spids: [1345 1349]
                                ) (" ")
                              ) (Lit_Other "*")
                            }
                            {(DQ (" ") ($ VSub_Name "$CC_quoted")) (Lit_Other "*")}
                            {(DQ ($ VSub_Name "$CC_quoted") (" ")) (Lit_Other "*")}
                            {
                              (DQ (" ") 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {($ VSub_Name "$echo")} {($ VSub_Name "$CC_quoted")})
                                      ]
                                    )
                                  left_token: <Left_Backtick "`">
                                  spids: [1374 1378]
                                ) (" ")
                              ) (Lit_Other "*")
                            }
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {($ VSub_Name "$echo")} {($ VSub_Name "$CC_quoted")})
                                      ]
                                    )
                                  left_token: <Left_Backtick "`">
                                  spids: [1386 1390]
                                ) (" ")
                              ) (Lit_Other "*")
                            }
                          ]
                          spids: [1315 1394 1396 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (ForEach
                              iter_name: z
                              iter_words: [{($ VSub_Name "$available_tags")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (SimpleCommand
                                                  words: [
                                                    {(grep)}
                                                    {
                                                      (DQ ("^# ### BEGIN LIBTOOL TAG CONFIG: ") 
                                                        ($ VSub_Name "$z") (Lit_Other "$")
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Less
                                                      fd: -1
                                                      arg_word: {(DQ ($ VSub_Name "$progpath"))}
                                                      spids: [1433]
                                                    )
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [1439]
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (SimpleCommand
                                                            words: [
                                                              {(${ VSub_Name SED)}
                                                              {(-n)}
                                                              {(-e)}
                                                              {
                                                                (SQ 
                                                                  <
"/^# ### BEGIN LIBTOOL TAG CONFIG: "
                                                                  >
                                                                ) ($ VSub_Name "$z") (SQ <"$/,/^# ### END LIBTOOL TAG CONFIG: ">) ($ VSub_Name "$z") (SQ <"$/p">)
                                                              }
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Less
                                                                fd: -1
                                                                arg_word: {($ VSub_Name "$progpath")}
                                                                spids: [1475]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [1454 1478]
                                                  )
                                                )
                                              }
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:CC_quoted)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [1482]
                                                )
                                              ]
                                              spids: [1482]
                                            )
                                            (ForEach
                                              iter_name: arg
                                              iter_words: [{($ VSub_Name "$CC")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Case
                                                      to_match: {($ VSub_Name "$arg")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") (Lit_Other "[") 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\[">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\^">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\(">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\}">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\<">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\'">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                                              (Lit_Other "]") (Lit_Other "*")
                                                            }
                                                            {(Lit_Other "*") (Lit_Other "]") 
                                                              (Lit_Other "*")
                                                            }
                                                            {(DQ )}
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:arg)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        (EscapedLiteralPart
                                                                          token: 
                                                                            <Lit_EscapedChar "\\\"">
                                                                        ) ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                      )
                                                                    }
                                                                  spids: [1540]
                                                                )
                                                              ]
                                                              spids: [1540]
                                                            )
                                                          ]
                                                          spids: [1508 1537 1548 -1]
                                                        )
                                                      ]
                                                      spids: [1501 1505 1551]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:CC_quoted)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$CC_quoted") (" ") 
                                                                ($ VSub_Name "$arg")
                                                              )
                                                            }
                                                          spids: [1554]
                                                        )
                                                      ]
                                                      spids: [1554]
                                                    )
                                                  ]
                                                  spids: [1494 1562]
                                                )
                                              spids: [1490 1492]
                                            )
                                            (Case
                                              to_match: {(DQ ($ VSub_At "$@") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(DQ (" ") ($ VSub_Name "$CC") (" ")) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(DQ ($ VSub_Name "$CC") (" ")) (Lit_Other "*")}
                                                    {
                                                      (DQ (" ") 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {($ VSub_Name "$echo")} 
                                                                  {($ VSub_Name "$CC")}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_Backtick "`">
                                                          spids: [1594 1598]
                                                        ) (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {($ VSub_Name "$echo")} 
                                                                  {($ VSub_Name "$CC")}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_Backtick "`">
                                                          spids: [1606 1610]
                                                        ) (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                    {(DQ (" ") ($ VSub_Name "$CC_quoted")) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(DQ ($ VSub_Name "$CC_quoted") (" ")) 
                                                      (Lit_Other "*")
                                                    }
                                                    {
                                                      (DQ (" ") 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {($ VSub_Name "$echo")} 
                                                                  {($ VSub_Name "$CC_quoted")}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_Backtick "`">
                                                          spids: [1635 1639]
                                                        ) (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {($ VSub_Name "$echo")} 
                                                                  {($ VSub_Name "$CC_quoted")}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_Backtick "`">
                                                          spids: [1647 1651]
                                                        ) (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tagname)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$z")}
                                                          spids: [1670]
                                                        )
                                                      ]
                                                      spids: [1670]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Break break>
                                                    )
                                                  ]
                                                  spids: [1576 1655 1677 -1]
                                                )
                                              ]
                                              spids: [1565 1572 1680]
                                            )
                                          ]
                                          spids: [-1 1444]
                                        )
                                      ]
                                      spids: [-1 1683]
                                    )
                                  ]
                                  spids: [1420 1686]
                                )
                              spids: [1416 1418]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$tagname"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {
                                        (DQ ($ VSub_Name "$modename") 
                                          (": unable to infer tagged configuration")
                                        )
                                      }
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": specify a tag with ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("--tag'")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [1732]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [-1 1712]
                                )
                              ]
                              spids: [-1 1747]
                            )
                          ]
                          spids: [1407 1408 1750 -1]
                        )
                      ]
                      spids: [1299 1303 1753]
                    )
                  ]
                  spids: [-1 1217]
                )
              ]
              spids: [-1 1756]
            )
          ]
          spids: [1193]
        )
      spids: [1188 1192]
    )
    (FuncDef
      name: func_extract_an_archive
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:f_ex_an_ar_dir)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [1773]
                    )
                  ]
                  spids: [1773]
                )
              terminator: <Op_Semi ";">
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:f_ex_an_ar_oldlib)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [1782]
                )
              ]
              spids: [1782]
            )
            (C {($ VSub_Name "$show")} 
              {
                (DQ ("(cd ") ($ VSub_Name "$f_ex_an_ar_dir") (" && ") ($ VSub_Name "$AR") (" x ") 
                  ($ VSub_Name "$f_ex_an_ar_oldlib") (")")
                )
              }
            )
            (AndOr
              children: [
                (C {($ VSub_Name "$run")} {(eval)} 
                  {
                    (DQ ("(cd ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                      ("f_ex_an_ar_dir && ") ($ VSub_Name "$AR") (" x ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("f_ex_an_ar_oldlib)")
                    )
                  }
                )
                (C {(exit)} {($ VSub_QMark "$?")})
              ]
              op_id: Op_DPipe
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Subshell
                          child: 
                            (Pipeline
                              children: [
                                (C {($ VSub_Name "$AR")} {(t)} {(DQ ($ VSub_Name "$f_ex_an_ar_oldlib"))})
                                (C {(sort)})
                                (SimpleCommand
                                  words: [{(sort)} {(-uc)}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(/dev/null)}
                                      spids: [1844]
                                    )
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 2
                                      arg_word: {(1)}
                                      spids: [1847]
                                    )
                                  ]
                                )
                              ]
                              negated: False
                            )
                          spids: [1825 1849]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(Lit_Other ":")})]
                  spids: [-1 1852]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [
                    {($ VSub_Name "$echo")}
                    {
                      (DQ ($ VSub_Name "$modename") (": ERROR: object name conflicts: ") 
                        ($ VSub_Name "$f_ex_an_ar_dir") (/) ($ VSub_Name "$f_ex_an_ar_oldlib")
                      )
                    }
                  ]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[1871])]
                )
                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
              ]
              spids: [1858 1880]
            )
          ]
          spids: [1770]
        )
      spids: [1765 1769]
    )
    (FuncDef
      name: func_extract_archives
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:my_gentop)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [1896]
                    )
                  ]
                  spids: [1896]
                )
              terminator: <Op_Semi ";">
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:my_oldlibs)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At "$@"))})
                        spids: [1906 1912]
                      )
                    }
                  spids: [1905]
                )
              ]
              spids: [1905]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:my_oldobjs) op:Equal rhs:{(DQ )} spids:[1915])]
              spids: [1915]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:my_xlib) op:Equal rhs:{(DQ )} spids:[1920])]
              spids: [1920]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:my_xabs) op:Equal rhs:{(DQ )} spids:[1925])]
              spids: [1925]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:my_xdir) op:Equal rhs:{(DQ )} spids:[1930])]
              spids: [1930]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:my_status) op:Equal rhs:{(DQ )} spids:[1935])]
              spids: [1935]
            )
            (C {($ VSub_Name "$show")} {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$my_gentop"))})
            (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} {(DQ ($ VSub_Name "$my_gentop"))})
            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$mkdir") (" ") ($ VSub_Name "$my_gentop"))})
            (C {($ VSub_Name "$run")} {($ VSub_Name "$mkdir")} {(DQ ($ VSub_Name "$my_gentop"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:my_status)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [1982]
                )
              ]
              spids: [1982]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(DQ ($ VSub_Name "$my_status"))} {(-ne)} {(0)})
                            (C {(test)} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$my_gentop"))})
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(exit)} {($ VSub_Name "$my_status")})]
                  spids: [-1 2011]
                )
              ]
              spids: [-1 2019]
            )
            (ForEach
              iter_name: my_xlib
              iter_words: [{($ VSub_Name "$my_oldlibs")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {($ VSub_Name "$my_xlib")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) 
                              (Lit_Other "]") (Lit_Other "*")
                            }
                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\\\">
                              ) (/) (Lit_Other "]") (Lit_Other "*")
                            }
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:my_xabs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$my_xlib"))}
                                  spids: [2065]
                                )
                              ]
                              spids: [2065]
                            )
                          ]
                          spids: [2046 2063 2070 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:my_xabs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: (CommandList children:[(C {(pwd)})])
                                        left_token: <Left_Backtick "`">
                                        spids: [2077 2079]
                                      ) (DQ (/) ($ VSub_Name "$my_xlib"))
                                    }
                                  spids: [2076]
                                )
                              ]
                              spids: [2076]
                            )
                          ]
                          spids: [2073 2074 2085 -1]
                        )
                      ]
                      spids: [2039 2043 2088]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:my_xlib)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$my_xlib"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [2092 2109]
                              )
                            }
                          spids: [2091]
                        )
                      ]
                      spids: [2091]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:my_xdir)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$my_gentop") (/) ($ VSub_Name "$my_xlib"))}
                          spids: [2112]
                        )
                      ]
                      spids: [2112]
                    )
                    (C {($ VSub_Name "$show")} {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$my_xdir"))})
                    (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} {(DQ ($ VSub_Name "$my_xdir"))})
                    (C {($ VSub_Name "$show")} 
                      {(DQ ($ VSub_Name "$mkdir") (" ") ($ VSub_Name "$my_xdir"))}
                    )
                    (C {($ VSub_Name "$run")} {($ VSub_Name "$mkdir")} {(DQ ($ VSub_Name "$my_xdir"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:exit_status)
                          op: Equal
                          rhs: {($ VSub_QMark "$?")}
                          spids: [2162]
                        )
                      ]
                      spids: [2162]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name "$exit_status"))} {(-ne)} {(0)})
                                    (C {(test)} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$my_xdir"))})
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(exit)} {($ VSub_Name "$exit_status")})]
                          spids: [-1 2191]
                        )
                      ]
                      spids: [-1 2199]
                    )
                    (Case
                      to_match: {($ VSub_Name "$host")}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (-darwin) (Lit_Other "*")}]
                          action: [
                            (C {($ VSub_Name "$show")} {(DQ ("Extracting ") ($ VSub_Name "$my_xabs"))})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:darwin_orig_dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: (CommandList children:[(C {(pwd)})])
                                                left_token: <Left_Backtick "`">
                                                spids: [2242 2244]
                                              )
                                            }
                                          spids: [2241]
                                        )
                                      ]
                                      spids: [2241]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(cd)} {($ VSub_Name "$my_xdir")})
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:darwin_archive)
                                          op: Equal
                                          rhs: {($ VSub_Name "$my_xabs")}
                                          spids: [2258]
                                        )
                                      ]
                                      spids: [2258]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:darwin_curdir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: (CommandList children:[(C {(pwd)})])
                                                left_token: <Left_Backtick "`">
                                                spids: [2263 2265]
                                              )
                                            }
                                          spids: [2262]
                                        )
                                      ]
                                      spids: [2262]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:darwin_base_archive)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ (X) ($ VSub_Name "$darwin_archive"))
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%^.*/%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2269 2286]
                                              )
                                            }
                                          spids: [2268]
                                        )
                                      ]
                                      spids: [2268]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:darwin_arches)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (SimpleCommand
                                                            words: [
                                                              {(lipo)}
                                                              {(-info)}
                                                              {(DQ ($ VSub_Name "$darwin_archive"))}
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Great
                                                                fd: 2
                                                                arg_word: {(/dev/null)}
                                                                spids: [2299]
                                                              )
                                                            ]
                                                          )
                                                          (SimpleCommand
                                                            words: [
                                                              {($ VSub_Name "$EGREP")}
                                                              {(Architectures)}
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Great
                                                                fd: 2
                                                                arg_word: {(/dev/null)}
                                                                spids: [2308]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2290 2310]
                                              )
                                            }
                                          spids: [2289]
                                        )
                                      ]
                                      spids: [2289]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$darwin_arches"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:darwin_arches)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {(echo)} 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$darwin_arches")
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$SED")} {(-e)} 
                                                                    {(SQ <"s/.*are://">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [2329 2345]
                                                      )
                                                    }
                                                  spids: [2328]
                                                )
                                              ]
                                              spids: [2328]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:darwin_arch)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [2348]
                                                )
                                              ]
                                              spids: [2348]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$darwin_base_archive") 
                                                  (" has multiple architectures ") ($ VSub_Name "$darwin_arches")
                                                )
                                              }
                                            )
                                            (ForEach
                                              iter_name: darwin_arch
                                              iter_words: [{($ VSub_Name "$darwin_arches")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (C {(mkdir)} {(-p)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar "$$") (/) 
                                                          (${ VSub_Name darwin_base_archive) (-) (${ VSub_Name darwin_arch)
                                                        )
                                                      }
                                                    )
                                                    (C {(lipo)} {(-thin)} {($ VSub_Name "$darwin_arch")} 
                                                      {(-output)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar "$$") (/) 
                                                          (${ VSub_Name darwin_base_archive) (-) (${ VSub_Name darwin_arch) (/) (${ VSub_Name darwin_base_archive)
                                                        )
                                                      } {(DQ (${ VSub_Name darwin_archive))}
                                                    )
                                                    (C {(cd)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar "$$") (/) 
                                                          (${ VSub_Name darwin_base_archive) (-) (${ VSub_Name darwin_arch)
                                                        )
                                                      }
                                                    )
                                                    (C {(func_extract_an_archive)} 
                                                      {
                                                        (DQ 
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [(C {(pwd)})]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [2442 2444]
                                                          )
                                                        )
                                                      } {(DQ (${ VSub_Name darwin_base_archive))}
                                                    )
                                                    (C {(cd)} {(DQ ($ VSub_Name "$darwin_curdir"))})
                                                    (C {($ VSub_Name "$rm")} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar "$$") (/) 
                                                          (${ VSub_Name darwin_base_archive) (-) (${ VSub_Name darwin_arch) (/) (${ VSub_Name darwin_base_archive)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [2370 2481]
                                                )
                                              spids: [2365 2368]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:darwin_filelist)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {(find)} 
                                                                    {(unfat-) ($ VSub_Dollar "$$")} {(-type)} {(f)} {(-name)} {(EscapedLiteralPart token:<Lit_EscapedChar "\\*">) (.o)} {(-print)} {(-o)} 
                                                                    {(-name)} {(EscapedLiteralPart token:<Lit_EscapedChar "\\*">) (.lo)} {(-print)}
                                                                  )
                                                                  (C {(xargs)} {(basename)})
                                                                  (C {(sort)} {(-u)})
                                                                  (C {($ VSub_Name "$NL2SP")})
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [2492 2532]
                                                      )
                                                    }
                                                  spids: [2491]
                                                )
                                              ]
                                              spids: [2491]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:darwin_file)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [2535]
                                                )
                                              ]
                                              spids: [2535]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:darwin_files)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [2538]
                                                )
                                              ]
                                              spids: [2538]
                                            )
                                            (ForEach
                                              iter_name: darwin_file
                                              iter_words: [{($ VSub_Name "$darwin_filelist")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:darwin_files)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {(find)} 
                                                                            {(unfat-) 
                                                                              ($ VSub_Dollar "$$")
                                                                            } {(-name)} {($ VSub_Name "$darwin_file")} {(-print)}
                                                                          )
                                                                          (C {($ VSub_Name "$NL2SP")})
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [2554 2569]
                                                              )
                                                            }
                                                          spids: [2553]
                                                        )
                                                      ]
                                                      spids: [2553]
                                                    )
                                                    (C {(lipo)} {(-create)} {(-output)} 
                                                      {(DQ ($ VSub_Name "$darwin_file"))} {($ VSub_Name "$darwin_files")}
                                                    )
                                                  ]
                                                  spids: [2550 2585]
                                                )
                                              spids: [2546 2548]
                                            )
                                            (C {(${ VSub_Name rm) (r)} {(unfat-) ($ VSub_Dollar "$$")})
                                            (C {(cd)} {(DQ ($ VSub_Name "$darwin_orig_dir"))})
                                          ]
                                          spids: [-1 2324]
                                        )
                                      ]
                                      else_action: [
                                        (C {(cd)} {(DQ ($ VSub_Name "$darwin_orig_dir"))})
                                        (C {(func_extract_an_archive)} {(DQ ($ VSub_Name "$my_xdir"))} 
                                          {(DQ ($ VSub_Name "$my_xabs"))}
                                        )
                                      ]
                                      spids: [2607 2628]
                                    )
                                  ]
                                  spids: [-1 2238]
                                )
                              ]
                              spids: [-1 2634]
                            )
                          ]
                          spids: [2209 2212 2640 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (C {(func_extract_an_archive)} {(DQ ($ VSub_Name "$my_xdir"))} 
                              {(DQ ($ VSub_Name "$my_xabs"))}
                            )
                          ]
                          spids: [2643 2644 2658 -1]
                        )
                      ]
                      spids: [2202 2206 2661]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:my_oldobjs)
                          op: Equal
                          rhs: 
                            {(DQ ($ VSub_Name "$my_oldobjs") (" ")) 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(find)} {($ VSub_Name "$my_xdir")} {(-name)} 
                                            {(EscapedLiteralPart token:<Lit_EscapedChar "\\*">) (.) 
                                              ($ VSub_Name "$objext")
                                            } {(-print)} {(-o)} {(-name)} {(EscapedLiteralPart token:<Lit_EscapedChar "\\*">) (.lo)} {(-print)}
                                          )
                                          (C {($ VSub_Name "$NL2SP")})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [2669 2694]
                              )
                            }
                          spids: [2664]
                        )
                      ]
                      spids: [2664]
                    )
                  ]
                  spids: [2032 2697]
                )
              spids: [2028 2030]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:func_extract_archives_result)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$my_oldobjs"))}
                  spids: [2700]
                )
              ]
              spids: [2700]
            )
          ]
          spids: [1893]
        )
      spids: [1888 1892]
    )
    (C {(eval)} 
      {(Lit_VarLike "std_shrext=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
        ($ VSub_Name "$shrext_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:disable_libs) op:Equal rhs:{(no)} spids:[2725])]
      spids: [2725]
    )
    (While
      cond: [(C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-gt)} {(0)})]
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:arg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2747]
                )
              ]
              spids: [2747]
            )
            (C {(shift)})
            (Case
              to_match: {($ VSub_Name "$arg")}
              arms: [
                (case_arm
                  pat_list: [{(-) (Lit_Other "*") (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:optarg)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$arg"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                            {(SQ <"s/[-_a-zA-Z0-9]*=//">)}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [2771 2788]
                              )
                            }
                          spids: [2770]
                        )
                      ]
                      spids: [2770]
                    )
                  ]
                  spids: [2764 2768 2790 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:optarg)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [2796]
                        )
                      ]
                      spids: [2796]
                    )
                  ]
                  spids: [2793 2794 2798 -1]
                )
              ]
              spids: [2757 2761 2801]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prev"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Case
                      to_match: {($ VSub_Name "$prev")}
                      arms: [
                        (case_arm
                          pat_list: [{(execute_dlfiles)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:execute_dlfiles)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$execute_dlfiles") (" ") ($ VSub_Name "$arg"))
                                    }
                                  spids: [2834]
                                )
                              ]
                              spids: [2834]
                            )
                          ]
                          spids: [2830 2831 2842 -1]
                        )
                        (case_arm
                          pat_list: [{(tag)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:tagname)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                  spids: [2849]
                                )
                              ]
                              spids: [2849]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:preserve_args)
                                  op: Equal
                                  rhs: {(DQ (${ VSub_Name preserve_args) ("=") ($ VSub_Name "$arg"))}
                                  spids: [2855]
                                )
                              ]
                              spids: [2855]
                            )
                            (Case
                              to_match: {($ VSub_Name "$tagname")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") (KW_Bang "!") (-_A-Za-z0-9) 
                                      (Lit_Comma ",") (/) (Lit_Other "]") (Lit_Other "*")
                                    }
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$progname") (": invalid tag name: ") 
                                            ($ VSub_Name "$tagname")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [2896]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [2877 2885 2905 -1]
                                )
                              ]
                              spids: [2870 2874 2908]
                            )
                            (Case
                              to_match: {($ VSub_Name "$tagname")}
                              arms: [
                                (case_arm
                                  pat_list: [{(CC)}]
                                  spids: [2919 2920 2931 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (SimpleCommand
                                                  words: [
                                                    {(grep)}
                                                    {
                                                      (DQ ("^# ### BEGIN LIBTOOL TAG CONFIG: ") 
                                                        ($ VSub_Name "$tagname") (Lit_Other "$")
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Less
                                                      fd: -1
                                                      arg_word: {(DQ ($ VSub_Name "$progpath"))}
                                                      spids: [2948]
                                                    )
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [2954]
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:taglist)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$taglist") (" ") 
                                                        ($ VSub_Name "$tagname")
                                                      )
                                                    }
                                                  spids: [2962]
                                                )
                                              ]
                                              spids: [2962]
                                            )
                                            (C {(eval)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (SimpleCommand
                                                            words: [
                                                              {(${ VSub_Name SED)}
                                                              {(-n)}
                                                              {(-e)}
                                                              {
                                                                (SQ 
                                                                  <
"/^# ### BEGIN LIBTOOL TAG CONFIG: "
                                                                  >
                                                                ) ($ VSub_Name "$tagname") (SQ <"$/,/^# ### END LIBTOOL TAG CONFIG: ">) ($ VSub_Name "$tagname") 
                                                                (SQ <"$/p">)
                                                              }
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Less
                                                                fd: -1
                                                                arg_word: {($ VSub_Name "$progpath")}
                                                                spids: [2998]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [2977 3001]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 2959]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$progname") 
                                                (": ignoring unknown tag ") ($ VSub_Name "$tagname")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [3016]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [3005 3020]
                                    )
                                  ]
                                  spids: [2934 2935 3023 -1]
                                )
                              ]
                              spids: [2912 2916 3026]
                            )
                          ]
                          spids: [2845 2846 3029 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (C {(eval)} 
                              {
                                (DQ ($ VSub_Name "$prev") ("=") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\$">
                                  ) (arg)
                                )
                              }
                            )
                          ]
                          spids: [3032 3033 3046 -1]
                        )
                      ]
                      spids: [2823 2827 3049]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:prev) op:Equal rhs:{(SQ )} spids:[3053])]
                      spids: [3053]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prevopt)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3056]
                        )
                      ]
                      spids: [3056]
                    )
                    (ControlFlow token:<ControlFlow_Continue continue>)
                  ]
                  spids: [-1 2820]
                )
              ]
              spids: [-1 3062]
            )
            (Case
              to_match: {($ VSub_Name "$arg")}
              arms: [
                (case_arm
                  pat_list: [{(--help)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:show_help)
                          op: Equal
                          rhs: {(yes)}
                          spids: [3081]
                        )
                      ]
                      spids: [3081]
                    )
                  ]
                  spids: [3077 3078 3085 -1]
                )
                (case_arm
                  pat_list: [{(--version)}]
                  action: [
                    (C {($ VSub_Name "$echo")} 
                      {
                        (DQ ($ VSub_Name "$PROGRAM") (" (GNU ") ($ VSub_Name "$PACKAGE") (") ") 
                          ($ VSub_Name "$VERSION") ($ VSub_Name "$TIMESTAMP")
                        )
                      }
                    )
                    (C {($ VSub_Name "$echo")})
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("Copyright (C) 2005  Free Software Foundation, Inc."))}
                    )
                    (C {($ VSub_Name "$echo")} 
                      {
                        (DQ 
                          (
"This is free software; see the source for copying conditions.  There is NO"
                          )
                        )
                      }
                    )
                    (C {($ VSub_Name "$echo")} 
                      {
                        (DQ 
                          (
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
                          )
                        )
                      }
                    )
                    (C {(exit)} {($ VSub_QMark "$?")})
                  ]
                  spids: [3089 3090 3134 -1]
                )
                (case_arm
                  pat_list: [{(--config)}]
                  action: [
                    (C {(${ VSub_Name SED)} {(-e)} {(SQ <"1,/^# ### BEGIN LIBTOOL CONFIG/d">)} {(-e)} 
                      {(SQ <"/^# ### END LIBTOOL CONFIG/,$d">)} {($ VSub_Name "$progpath")}
                    )
                    (ForEach
                      iter_name: tagname
                      iter_words: [{($ VSub_Name "$taglist")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (SimpleCommand
                              words: [
                                {(${ VSub_Name SED)}
                                {(-n)}
                                {(-e)}
                                {
                                  (DQ ("/^# ### BEGIN LIBTOOL TAG CONFIG: ") ($ VSub_Name "$tagname") 
                                    (Lit_Other "$") ("/,/^# ### END LIBTOOL TAG CONFIG: ") ($ VSub_Name "$tagname") (Lit_Other "$") (/p)
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Less
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$progpath"))}
                                  spids: [3195]
                                )
                              ]
                            )
                          ]
                          spids: [3174 3202]
                        )
                      spids: [3170 3172]
                    )
                    (C {(exit)} {($ VSub_QMark "$?")})
                  ]
                  spids: [3138 3139 3210 -1]
                )
                (case_arm
                  pat_list: [{(--debug)}]
                  action: [
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ($ VSub_Name "$progname") (": enabling shell trace mode"))}
                    )
                    (C {(set)} {(-x)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preserve_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$preserve_args") (" ") ($ VSub_Name "$arg"))}
                          spids: [3231]
                        )
                      ]
                      spids: [3231]
                    )
                  ]
                  spids: [3214 3215 3239 -1]
                )
                (case_arm
                  pat_list: [{(--dry-run)} {(-n)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:run)
                          op: Equal
                          rhs: {(Lit_Other ":")}
                          spids: [3251]
                        )
                      ]
                      spids: [3251]
                    )
                  ]
                  spids: [3243 3248 3255 -1]
                )
                (case_arm
                  pat_list: [{(--features)}]
                  action: [
                    (C {($ VSub_Name "$echo")} {(DQ ("host: ") ($ VSub_Name "$host"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {($ VSub_Name "$echo")} {(DQ ("enable shared libraries"))})]
                          spids: [-1 3284]
                        )
                      ]
                      else_action: [(C {($ VSub_Name "$echo")} {(DQ ("disable shared libraries"))})]
                      spids: [3294 3304]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {($ VSub_Name "$echo")} {(DQ ("enable static libraries"))})]
                          spids: [-1 3320]
                        )
                      ]
                      else_action: [(C {($ VSub_Name "$echo")} {(DQ ("disable static libraries"))})]
                      spids: [3330 3340]
                    )
                    (C {(exit)} {($ VSub_QMark "$?")})
                  ]
                  spids: [3259 3260 3348 -1]
                )
                (case_arm
                  pat_list: [{(--finish)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mode)
                          op: Equal
                          rhs: {(DQ (finish))}
                          spids: [3355]
                        )
                      ]
                      spids: [3355]
                    )
                  ]
                  spids: [3352 3353 3360 -1]
                )
                (case_arm
                  pat_list: [{(--mode)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prevopt)
                          op: Equal
                          rhs: {(DQ (--mode))}
                          spids: [3367]
                        )
                        (assign_pair
                          lhs: (LhsName name:prev)
                          op: Equal
                          rhs: {(mode)}
                          spids: [3372]
                        )
                      ]
                      spids: [3367]
                    )
                  ]
                  spids: [3364 3365 3375 -1]
                )
                (case_arm
                  pat_list: [{(--mode) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:mode)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$optarg"))}
                          spids: [3383]
                        )
                      ]
                      spids: [3383]
                    )
                  ]
                  spids: [3378 3381 3388 -1]
                )
                (case_arm
                  pat_list: [{(--preserve-dup-deps)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:duplicate_deps)
                          op: Equal
                          rhs: {(DQ (yes))}
                          spids: [3395]
                        )
                      ]
                      spids: [3395]
                    )
                  ]
                  spids: [3392 3393 3400 -1]
                )
                (case_arm
                  pat_list: [{(--quiet)} {(--silent)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:show)
                          op: Equal
                          rhs: {(Lit_Other ":")}
                          spids: [3412]
                        )
                      ]
                      spids: [3412]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preserve_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$preserve_args") (" ") ($ VSub_Name "$arg"))}
                          spids: [3416]
                        )
                      ]
                      spids: [3416]
                    )
                  ]
                  spids: [3404 3409 3424 -1]
                )
                (case_arm
                  pat_list: [{(--tag)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prevopt)
                          op: Equal
                          rhs: {(DQ (--tag))}
                          spids: [3432]
                        )
                      ]
                      spids: [3432]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:prev) op:Equal rhs:{(tag)} spids:[3438])]
                      spids: [3438]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preserve_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$preserve_args") (" --tag"))}
                          spids: [3442]
                        )
                      ]
                      spids: [3442]
                    )
                  ]
                  spids: [3428 3429 3449 -1]
                )
                (case_arm
                  pat_list: [{(--tag) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (C {(set)} {(tag)} {(DQ ($ VSub_Name "$optarg"))} 
                      {
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At "$@"))})
                          spids: [3466 3472]
                        )
                      }
                    )
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:prev) op:Equal rhs:{(tag)} spids:[3478])]
                      spids: [3478]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preserve_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$preserve_args") (" --tag"))}
                          spids: [3482]
                        )
                      ]
                      spids: [3482]
                    )
                  ]
                  spids: [3452 3455 3489 -1]
                )
                (case_arm
                  pat_list: [{(-dlopen)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prevopt)
                          op: Equal
                          rhs: {(DQ (-dlopen))}
                          spids: [3497]
                        )
                      ]
                      spids: [3497]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prev)
                          op: Equal
                          rhs: {(execute_dlfiles)}
                          spids: [3503]
                        )
                      ]
                      spids: [3503]
                    )
                  ]
                  spids: [3493 3494 3507 -1]
                )
                (case_arm
                  pat_list: [{(-) (Lit_Other "*")}]
                  action: [
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {
                          (DQ ($ VSub_Name "$modename") (": unrecognized option ") 
                            (EscapedLiteralPart
                              token: <Lit_EscapedChar "\\`">
                            ) ($ VSub_Name "$arg") ("'")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3526])]
                    )
                    (SimpleCommand
                      words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3536])]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                  ]
                  spids: [3511 3513 3545 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:nonopt)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$arg"))}
                          spids: [3553]
                        )
                      ]
                      spids: [3553]
                    )
                    (ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [3549 3550 3562 -1]
                )
              ]
              spids: [3070 3074 3565]
            )
          ]
          spids: [2744 3567]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prevopt"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {($ VSub_Name "$echo")}
                {
                  (DQ ($ VSub_Name "$modename") (": option ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$prevopt") ("' requires an argument")
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3594])]
            )
            (SimpleCommand
              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3604])]
            )
            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
          ]
          spids: [-1 3581]
        )
      ]
      spids: [-1 3612]
    )
    (Case
      to_match: {($ VSub_Name "$disable_libs")}
      arms: [
        (case_arm pat_list:[{(no)}] spids:[362136223626-1])
        (case_arm
          pat_list: [{(shared)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:build_libtool_libs)
                  op: Equal
                  rhs: {(no)}
                  spids: [3632]
                )
              ]
              spids: [3632]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:build_old_libs)
                  op: Equal
                  rhs: {(yes)}
                  spids: [3636]
                )
              ]
              spids: [3636]
            )
          ]
          spids: [3628 3629 3640 -1]
        )
        (case_arm
          pat_list: [{(static)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:build_old_libs)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Case
                                to_match: {($ VSub_Name "$build_libtool_libs")}
                                arms: [
                                  (case_arm
                                    pat_list: [{(yes)}]
                                    action: [(C {(echo)} {(no)})]
                                    spids: [3654 3655 3660 -1]
                                  )
                                  (case_arm
                                    pat_list: [{(Lit_Other "*")}]
                                    action: [(C {(echo)} {(yes)})]
                                    spids: [3662 3663 3668 -1]
                                  )
                                ]
                                spids: [3648 3652 3670]
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [3647 3671]
                      )
                    }
                  spids: [3646]
                )
              ]
              spids: [3646]
            )
          ]
          spids: [3642 3643 3674 -1]
        )
      ]
      spids: [3615 3619 3676]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:exec_cmd) op:Equal rhs:{(SQ )} spids:[3688])]
      spids: [3688]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$show_help"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$mode"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {(DQ ("*** Warning: inferring the mode of operation is deprecated."))}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3730])]
                    )
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {
                          (DQ 
                            (
"*** Future versions of Libtool will require --mode=MODE be specified."
                            )
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[3740])]
                    )
                    (Case
                      to_match: {($ VSub_Name "$nonopt")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (cc)}
                            {(cc) (Lit_Other "*")}
                            {(Lit_Other "*") (Lit_Other "+") (Lit_Other "+")}
                            {(gcc) (Lit_Other "*")}
                            {(Lit_Other "*") (-gcc) (Lit_Other "*")}
                            {(g) (Lit_Other "+") (Lit_Other "+") (Lit_Other "*")}
                            {(xlc) (Lit_Other "*")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:mode)
                                  op: Equal
                                  rhs: {(link)}
                                  spids: [3790]
                                )
                              ]
                              spids: [3790]
                            )
                            (ForEach
                              iter_name: arg
                              do_arg_iter: True
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {($ VSub_Name "$arg")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-c)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:mode)
                                                  op: Equal
                                                  rhs: {(compile)}
                                                  spids: [3813]
                                                )
                                              ]
                                              spids: [3813]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Break break>
                                            )
                                          ]
                                          spids: [3809 3810 3820 -1]
                                        )
                                      ]
                                      spids: [3802 3806 3823]
                                    )
                                  ]
                                  spids: [3799 3826]
                                )
                              spids: [-1 -1]
                            )
                          ]
                          spids: [3751 3787 3829 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (db)}
                            {(Lit_Other "*") (dbx)}
                            {(Lit_Other "*") (strace)}
                            {(Lit_Other "*") (truss)}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:mode)
                                  op: Equal
                                  rhs: {(execute)}
                                  spids: [3852]
                                )
                              ]
                              spids: [3852]
                            )
                          ]
                          spids: [3832 3849 3856 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (install) (Lit_Other "*")} {(cp)} {(mv)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:mode)
                                  op: Equal
                                  rhs: {(install)}
                                  spids: [3869]
                                )
                              ]
                              spids: [3869]
                            )
                          ]
                          spids: [3859 3866 3873 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (rm)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:mode)
                                  op: Equal
                                  rhs: {(uninstall)}
                                  spids: [3881]
                                )
                              ]
                              spids: [3881]
                            )
                          ]
                          spids: [3876 3878 3885 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$execute_dlfiles"))})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:mode)
                                      op: Equal
                                      rhs: {(execute)}
                                      spids: [3906]
                                    )
                                  ]
                                  spids: [3906]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$mode"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$nonopt"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (
": warning: cannot infer operation mode from "
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$nonopt") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [3953]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 3940]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") 
                                                (
": warning: cannot infer operation mode without MODE-ARGS"
                                                )
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [3967]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [3957 3971]
                                    )
                                  ]
                                  spids: [-1 3926]
                                )
                              ]
                              spids: [-1 3974]
                            )
                          ]
                          spids: [3888 3889 3977 -1]
                        )
                      ]
                      spids: [3744 3748 3980]
                    )
                  ]
                  spids: [-1 3721]
                )
              ]
              spids: [-1 3983]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$execute_dlfiles"))})
                            (C {(test)} {(DQ ($ VSub_Name "$mode"))} {(KW_Bang "!") (Lit_Other "=")} 
                              {(execute)}
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {
                          (DQ ($ VSub_Name "$modename") (": unrecognized option ") 
                            (EscapedLiteralPart
                              token: <Lit_EscapedChar "\\`">
                            ) ("-dlopen'")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[4027])]
                    )
                    (SimpleCommand
                      words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[4037])]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                  ]
                  spids: [-1 4015]
                )
              ]
              spids: [-1 4046]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:generic_help)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$help"))}
                  spids: [4054]
                )
              ]
              spids: [4054]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:help)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("Try ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                        ($ VSub_Name "$modename") (" --help --mode=") ($ VSub_Name "$mode") ("' for more information.")
                      )
                    }
                  spids: [4060]
                )
              ]
              spids: [4060]
            )
            (Case
              to_match: {($ VSub_Name "$mode")}
              arms: [
                (case_arm
                  pat_list: [{(compile)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": compile"))}
                          spids: [4091]
                        )
                      ]
                      spids: [4091]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base_compile)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [4102]
                        )
                      ]
                      spids: [4102]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:srcfile)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [4105]
                        )
                      ]
                      spids: [4105]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:suppress_opt)
                          op: Equal
                          rhs: {(yes)}
                          spids: [4114]
                        )
                      ]
                      spids: [4114]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:suppress_output)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [4118]
                        )
                      ]
                      spids: [4118]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:arg_mode)
                          op: Equal
                          rhs: {(normal)}
                          spids: [4121]
                        )
                      ]
                      spids: [4121]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libobj)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [4125]
                        )
                      ]
                      spids: [4125]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:later)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [4128]
                        )
                      ]
                      spids: [4128]
                    )
                    (ForEach
                      iter_name: arg
                      do_arg_iter: True
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$arg_mode")}
                              arms: [
                                (case_arm
                                  pat_list: [{(arg)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lastarg)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$arg"))}
                                          spids: [4156]
                                        )
                                      ]
                                      spids: [4156]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg_mode)
                                          op: Equal
                                          rhs: {(normal)}
                                          spids: [4162]
                                        )
                                      ]
                                      spids: [4162]
                                    )
                                  ]
                                  spids: [4147 4149 4166 -1]
                                )
                                (case_arm
                                  pat_list: [{(target)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libobj)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$arg"))}
                                          spids: [4175]
                                        )
                                      ]
                                      spids: [4175]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg_mode)
                                          op: Equal
                                          rhs: {(normal)}
                                          spids: [4181]
                                        )
                                      ]
                                      spids: [4181]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [4170 4172 4188 -1]
                                )
                                (case_arm
                                  pat_list: [{(normal)}]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$arg")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-o)}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$libobj"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": you cannot specify ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-o' more than once")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [4236]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 4224]
                                                )
                                              ]
                                              spids: [-1 4245]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg_mode)
                                                  op: Equal
                                                  rhs: {(target)}
                                                  spids: [4248]
                                                )
                                              ]
                                              spids: [4248]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [4208 4209 4255 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-static)} {(-prefer-pic)} {(-prefer-non-pic)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:later)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$later") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [4271]
                                                )
                                              ]
                                              spids: [4271]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [4259 4268 4282 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-no-suppress)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:suppress_opt)
                                                  op: Equal
                                                  rhs: {(no)}
                                                  spids: [4290]
                                                )
                                              ]
                                              spids: [4290]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [4286 4287 4297 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-Xcompiler)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg_mode)
                                                  op: Equal
                                                  rhs: {(arg)}
                                                  spids: [4305]
                                                )
                                              ]
                                              spids: [4305]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [4301 4302 4318 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-Wc) (Lit_Comma ",") (Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:args)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$arg"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ("s/^-Wc,//"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [4332 4349]
                                                      )
                                                    }
                                                  spids: [4331]
                                                )
                                              ]
                                              spids: [4331]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lastarg)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [4352]
                                                )
                                              ]
                                              spids: [4352]
                                            )
                                            (Sentence
                                              child: 
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:save_ifs)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                      spids: [4355]
                                                    )
                                                  ]
                                                  spids: [4355]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(SQ <",">)}
                                                  spids: [4361]
                                                )
                                              ]
                                              spids: [4361]
                                            )
                                            (ForEach
                                              iter_name: arg
                                              iter_words: [{($ VSub_Name "$args")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                          spids: [4379]
                                                        )
                                                      ]
                                                      spids: [4379]
                                                    )
                                                    (Case
                                                      to_match: {($ VSub_Name "$arg")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") (Lit_Other "[") 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\[">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\^">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\(">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\}">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\<">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\'">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                                              (Lit_Other "]") (Lit_Other "*")
                                                            }
                                                            {(Lit_Other "*") (Lit_Other "]") 
                                                              (Lit_Other "*")
                                                            }
                                                            {(DQ )}
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:arg)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        (EscapedLiteralPart
                                                                          token: 
                                                                            <Lit_EscapedChar "\\\"">
                                                                        ) ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                      )
                                                                    }
                                                                  spids: [4437]
                                                                )
                                                              ]
                                                              spids: [4437]
                                                            )
                                                          ]
                                                          spids: [4405 4434 4445 -1]
                                                        )
                                                      ]
                                                      spids: [4398 4402 4448]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:lastarg)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$lastarg") (" ") 
                                                                ($ VSub_Name "$arg")
                                                              )
                                                            }
                                                          spids: [4451]
                                                        )
                                                      ]
                                                      spids: [4451]
                                                    )
                                                  ]
                                                  spids: [4376 4459]
                                                )
                                              spids: [4372 4374]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [4462]
                                                )
                                              ]
                                              spids: [4462]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lastarg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) ($ VSub_Name "$lastarg"))
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ("s/^ //"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [4469 4486]
                                                      )
                                                    }
                                                  spids: [4468]
                                                )
                                              ]
                                              spids: [4468]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:base_compile)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$base_compile") (" ") 
                                                        ($ VSub_Name "$lastarg")
                                                      )
                                                    }
                                                  spids: [4494]
                                                )
                                              ]
                                              spids: [4494]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [4325 4328 4505 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lastarg)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$srcfile"))}
                                                  spids: [4526]
                                                )
                                              ]
                                              spids: [4526]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:srcfile)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [4532]
                                                )
                                              ]
                                              spids: [4532]
                                            )
                                          ]
                                          spids: [4509 4511 4538 -1]
                                        )
                                      ]
                                      spids: [4201 4205 4541]
                                    )
                                  ]
                                  spids: [4192 4194 4547 -1]
                                )
                              ]
                              spids: [4140 4144 4550]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:lastarg)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$lastarg"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [4562 4579]
                                      )
                                    }
                                  spids: [4561]
                                )
                              ]
                              spids: [4561]
                            )
                            (Case
                              to_match: {($ VSub_Name "$lastarg")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\[">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\^">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\(">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\}">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\<">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\'">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                    {(DQ )}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lastarg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                ($ VSub_Name "$lastarg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              )
                                            }
                                          spids: [4646]
                                        )
                                      ]
                                      spids: [4646]
                                    )
                                  ]
                                  spids: [4614 4643 4654 -1]
                                )
                              ]
                              spids: [4583 4587 4657]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:base_compile)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$base_compile") (" ") ($ VSub_Name "$lastarg"))
                                    }
                                  spids: [4661]
                                )
                              ]
                              spids: [4661]
                            )
                          ]
                          spids: [4137 4669]
                        )
                      spids: [-1 -1]
                    )
                    (Case
                      to_match: {($ VSub_Name "$arg_mode")}
                      arms: [
                        (case_arm
                          pat_list: [{(arg)}]
                          action: [
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ($ VSub_Name "$modename") 
                                  (": you must specify an argument for -Xcompile")
                                )
                              }
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [4683 4684 4700 -1]
                        )
                        (case_arm
                          pat_list: [{(target)}]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") (": you must specify a target with ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\`">
                                    ) ("-o'")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [4716]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [4703 4704 4725 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (AndOr
                              children: [
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$libobj"))} 
                                  {(Lit_Other "]")}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:libobj)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {($ VSub_Name "$echo")} 
                                                        {(DQ (X) ($ VSub_Name "$srcfile"))}
                                                      )
                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                        {(SQ <"s%^.*/%%">)}
                                                      )
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [4749 4766]
                                          )
                                        }
                                      spids: [4748]
                                    )
                                  ]
                                  spids: [4748]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [4728 4729 4769 -1]
                        )
                      ]
                      spids: [4676 4680 4772]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:xform)
                          op: Equal
                          rhs: {(SQ <"[cCFSifmso]">)}
                          spids: [4784]
                        )
                      ]
                      spids: [4784]
                    )
                    (Case
                      to_match: {($ VSub_Name "$libobj")}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.ada)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(ada)}
                                  spids: [4801]
                                )
                              ]
                              spids: [4801]
                            )
                          ]
                          spids: [4797 4799 4804 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.adb)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(adb)}
                                  spids: [4811]
                                )
                              ]
                              spids: [4811]
                            )
                          ]
                          spids: [4807 4809 4814 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.ads)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(ads)}
                                  spids: [4821]
                                )
                              ]
                              spids: [4821]
                            )
                          ]
                          spids: [4817 4819 4824 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.asm)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(asm)}
                                  spids: [4831]
                                )
                              ]
                              spids: [4831]
                            )
                          ]
                          spids: [4827 4829 4834 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.c) (Lit_Other "+") (Lit_Other "+")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(c) (Lit_Other "+") (Lit_Other "+")}
                                  spids: [4843]
                                )
                              ]
                              spids: [4843]
                            )
                          ]
                          spids: [4837 4841 4848 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.cc)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(cc)}
                                  spids: [4855]
                                )
                              ]
                              spids: [4855]
                            )
                          ]
                          spids: [4851 4853 4858 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.ii)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(ii)}
                                  spids: [4865]
                                )
                              ]
                              spids: [4865]
                            )
                          ]
                          spids: [4861 4863 4868 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.class)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(class)}
                                  spids: [4875]
                                )
                              ]
                              spids: [4875]
                            )
                          ]
                          spids: [4871 4873 4878 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.cpp)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(cpp)}
                                  spids: [4885]
                                )
                              ]
                              spids: [4885]
                            )
                          ]
                          spids: [4881 4883 4888 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.cxx)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(cxx)}
                                  spids: [4895]
                                )
                              ]
                              spids: [4895]
                            )
                          ]
                          spids: [4891 4893 4898 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.f90)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(f90)}
                                  spids: [4905]
                                )
                              ]
                              spids: [4905]
                            )
                          ]
                          spids: [4901 4903 4908 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.for)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(KW_For for)}
                                  spids: [4915]
                                )
                              ]
                              spids: [4915]
                            )
                          ]
                          spids: [4911 4913 4918 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.java)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xform)
                                  op: Equal
                                  rhs: {(java)}
                                  spids: [4925]
                                )
                              ]
                              spids: [4925]
                            )
                          ]
                          spids: [4921 4923 4928 -1]
                        )
                      ]
                      spids: [4790 4794 4931]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libobj)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$libobj"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                            {
                                              (DQ (s/) 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\.">
                                                ) ($ VSub_Name "$xform") (Lit_Other "$") (/.lo/)
                                              )
                                            }
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [4936 4957]
                              )
                            }
                          spids: [4935]
                        )
                      ]
                      spids: [4935]
                    )
                    (Case
                      to_match: {($ VSub_Name "$libobj")}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.lo)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:obj)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$libobj"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$lo2o"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [4973 4990]
                                      )
                                    }
                                  spids: [4972]
                                )
                              ]
                              spids: [4972]
                            )
                          ]
                          spids: [4968 4970 4992 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") 
                                    (": cannot determine name of library object from ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$libobj") ("'")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [5009]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [4995 4996 5018 -1]
                        )
                      ]
                      spids: [4961 4965 5021]
                    )
                    (C {(func_infer_tag)} {($ VSub_Name "$base_compile")})
                    (ForEach
                      iter_name: arg
                      iter_words: [{($ VSub_Name "$later")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-static)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:build_old_libs)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [5054]
                                        )
                                      ]
                                      spids: [5054]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [5050 5051 5061 -1]
                                )
                                (case_arm
                                  pat_list: [{(-prefer-pic)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:pic_mode)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [5069]
                                        )
                                      ]
                                      spids: [5069]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [5065 5066 5076 -1]
                                )
                                (case_arm
                                  pat_list: [{(-prefer-non-pic)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:pic_mode)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [5084]
                                        )
                                      ]
                                      spids: [5084]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [5080 5081 5091 -1]
                                )
                              ]
                              spids: [5043 5047 5094]
                            )
                          ]
                          spids: [5040 5097]
                        )
                      spids: [5036 5038]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:qlibobj)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$libobj"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [5102 5119]
                              )
                            }
                          spids: [5101]
                        )
                      ]
                      spids: [5101]
                    )
                    (Case
                      to_match: {($ VSub_Name "$qlibobj")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (Lit_Other "[") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\[">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\^">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\(">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\}">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\<">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\'">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                              (Lit_Other "]") (Lit_Other "*")
                            }
                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                            {(DQ )}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:qlibobj)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                        ($ VSub_Name "$qlibobj") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      )
                                    }
                                  spids: [5161]
                                )
                              ]
                              spids: [5161]
                            )
                          ]
                          spids: [5129 5158 5168 -1]
                        )
                      ]
                      spids: [5122 5126 5171]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(DQ (X) ($ VSub_Name "$libobj"))} {(KW_Bang "!") (Lit_Other "=")} 
                          {(DQ (X) ($ VSub_Name "$qlibobj"))}
                        )
                        (AndOr
                          children: [
                            (Pipeline
                              children: [
                                (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$libobj"))})
                                (C {(grep)} {(SQ <"[]~#^*{};<>?\"">) (DQ ("'")) (SQ <" \t&()|`$[]">)})
                              ]
                              negated: False
                            )
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ($ VSub_Name "$modename") (": libobj name ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\`">
                                  ) ($ VSub_Name "$libobj") ("' may not contain shell special characters.")
                                )
                              }
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:objname)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$obj"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [5230 5247]
                              )
                            }
                          spids: [5229]
                        )
                      ]
                      spids: [5229]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:xdir)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$obj"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%/[^/]*$%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [5251 5268]
                              )
                            }
                          spids: [5250]
                        )
                      ]
                      spids: [5250]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ (X) ($ VSub_Name "$xdir"))} {(Lit_Other "=")} 
                                  {(DQ (X) ($ VSub_Name "$obj"))}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xdir)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [5291]
                                )
                              ]
                              spids: [5291]
                            )
                          ]
                          spids: [-1 5288]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:xdir)
                              op: Equal
                              rhs: {($ VSub_Name "$xdir") (/)}
                              spids: [5297]
                            )
                          ]
                          spids: [5297]
                        )
                      ]
                      spids: [5294 5302]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:lobj)
                          op: Equal
                          rhs: 
                            {(${ VSub_Name xdir) ($ VSub_Name "$objdir") (/) ($ VSub_Name "$objname")}
                          spids: [5305]
                        )
                      ]
                      spids: [5305]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$base_compile"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") 
                                    (": you must specify a compilation command")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [5336]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [5346]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 5326]
                        )
                      ]
                      spids: [-1 5355]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:removelist)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$obj") (" ") ($ VSub_Name "$lobj") (" ") 
                                        ($ VSub_Name "$libobj") (" ") (${ VSub_Name libobj) (T)
                                      )
                                    }
                                  spids: [5379]
                                )
                              ]
                              spids: [5379]
                            )
                          ]
                          spids: [-1 5376]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:removelist)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_Name "$lobj") (" ") ($ VSub_Name "$libobj") (" ") 
                                    (${ VSub_Name libobj) (T)
                                  )
                                }
                              spids: [5397]
                            )
                          ]
                          spids: [5397]
                        )
                      ]
                      spids: [5394 5410]
                    )
                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {($ VSub_Name "$removelist")})
                    (C {(trap)} 
                      {
                        (DQ ($ VSub_Name "$run") (" ") ($ VSub_Name "$rm") (" ") 
                          ($ VSub_Name "$removelist") ("; exit ") ($ VSub_Name "$EXIT_FAILURE")
                        )
                      } {(1)} {(2)} {(15)}
                    )
                    (Case
                      to_match: {($ VSub_Name "$host_os")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(cygwin) (Lit_Other "*")}
                            {(mingw) (Lit_Other "*")}
                            {(pw32) (Lit_Other "*")}
                            {(os2) (Lit_Other "*")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pic_mode)
                                  op: Equal
                                  rhs: {(default)}
                                  spids: [5472]
                                )
                              ]
                              spids: [5472]
                            )
                          ]
                          spids: [5452 5469 5476 -1]
                        )
                      ]
                      spids: [5445 5449 5479]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name "$pic_mode"))} {(Lit_Other "=")} {(no)})
                                    (C {(test)} {(DQ ($ VSub_Name "$deplibs_check_method"))} 
                                      {(KW_Bang "!") (Lit_Other "=")} {(pass_all)}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pic_mode)
                                  op: Equal
                                  rhs: {(default)}
                                  spids: [5515]
                                )
                              ]
                              spids: [5515]
                            )
                          ]
                          spids: [-1 5508]
                        )
                      ]
                      spids: [-1 5519]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$compiler_c_o"))} {(Lit_Other "=")} {(no)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:output_obj)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$srcfile"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)} 
                                                    {(-e)} {(SQ <"s%\\.[^.]*$%%">)}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [5548 5571]
                                      ) (.) (${ VSub_Name objext)
                                    }
                                  spids: [5547]
                                )
                              ]
                              spids: [5547]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:lockfile)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$output_obj") (.lock))}
                                  spids: [5578]
                                )
                              ]
                              spids: [5578]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:removelist)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$removelist") (" ") ($ VSub_Name "$output_obj") 
                                        (" ") ($ VSub_Name "$lockfile")
                                      )
                                    }
                                  spids: [5585]
                                )
                              ]
                              spids: [5585]
                            )
                            (C {(trap)} 
                              {
                                (DQ ($ VSub_Name "$run") (" ") ($ VSub_Name "$rm") (" ") 
                                  ($ VSub_Name "$removelist") ("; exit ") ($ VSub_Name "$EXIT_FAILURE")
                                )
                              } {(1)} {(2)} {(15)}
                            )
                          ]
                          spids: [-1 5544]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:output_obj)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [5617]
                            )
                          ]
                          spids: [5617]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:need_locks)
                              op: Equal
                              rhs: {(no)}
                              spids: [5620]
                            )
                          ]
                          spids: [5620]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:lockfile)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [5624]
                            )
                          ]
                          spids: [5624]
                        )
                      ]
                      spids: [5614 5627]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$need_locks"))} {(Lit_Other "=")} {(yes)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Until
                              cond: [
                                (Sentence
                                  child: 
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$run")}
                                        {(ln)}
                                        {(DQ ($ VSub_Name "$progpath"))}
                                        {(DQ ($ VSub_Name "$lockfile"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                          spids: [5669]
                                        )
                                      ]
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              body: 
                                (DoGroup
                                  children: [
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ("Waiting for ") ($ VSub_Name "$lockfile") 
                                          (" to be removed")
                                        )
                                      }
                                    )
                                    (C {(sleep)} {(2)})
                                  ]
                                  spids: [5673 5690]
                                )
                            )
                          ]
                          spids: [-1 5652]
                        )
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$need_locks"))} {(Lit_Other "=")} {(warn)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-f)} {(DQ ($ VSub_Name "$lockfile"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {
                                        (DQ ("*** ERROR, ") ($ VSub_Name "$lockfile") 
                                          (" exists and contains:\n") 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(cat)} {($ VSub_Name "$lockfile")}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [5735]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [5730 5737]
                                          ) ("\n") ("\n") ("This indicates that another process is trying to use the same\n") 
                                          (
"temporary object file, and libtool could not work around it because\n"
                                          ) ("your compiler does not support ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-c' and ") 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\`">
                                          ) ("-o' together.  If you\n") 
                                          (
"repeat this compilation, it may succeed, by chance, but you had better\n"
                                          ) ("avoid parallel builds (make -j) in this platform, or get a better\n") (compiler.)
                                        )
                                      }
                                    )
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                      {($ VSub_Name "$removelist")}
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [-1 5720]
                                )
                              ]
                              spids: [-1 5766]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$srcfile"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$lockfile"))}
                                  spids: [5775]
                                )
                              ]
                            )
                          ]
                          spids: [5693 5706]
                        )
                      ]
                      spids: [-1 5782]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$fix_srcfile_path"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {(Lit_VarLike "srcfile=") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                ) ($ VSub_Name "$fix_srcfile_path") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                              }
                            )
                          ]
                          spids: [-1 5797]
                        )
                      ]
                      spids: [-1 5808]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:qsrcfile)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$srcfile"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [5812 5829]
                              )
                            }
                          spids: [5811]
                        )
                      ]
                      spids: [5811]
                    )
                    (Case
                      to_match: {($ VSub_Name "$qsrcfile")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (Lit_Other "[") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\[">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\^">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\(">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\}">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\<">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\'">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                              (Lit_Other "]") (Lit_Other "*")
                            }
                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                            {(DQ )}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:qsrcfile)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                        ($ VSub_Name "$qsrcfile") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      )
                                    }
                                  spids: [5871]
                                )
                              ]
                              spids: [5871]
                            )
                          ]
                          spids: [5839 5868 5878 -1]
                        )
                      ]
                      spids: [5832 5836 5881]
                    )
                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {(DQ ($ VSub_Name "$libobj"))} 
                      {(DQ (${ VSub_Name libobj) (T))}
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                        (SimpleCommand
                          words: [{(cat)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(${ VSub_Name libobj) (T)}
                              spids: [5922]
                            )
                            (HereDoc
                              op_id: Redir_DLess
                              fd: -1
                              body: 
                                {
                                  (DQ ("# ") ($ VSub_Name "$libobj") (" - a libtool object file\n") 
                                    ("# Generated by ") ($ VSub_Name "$PROGRAM") (" - GNU ") ($ VSub_Name "$PACKAGE") (" ") ($ VSub_Name "$VERSION") 
                                    ($ VSub_Name "$TIMESTAMP") ("\n") ("#\n") ("# Please DO NOT delete this file!\n") ("# It is necessary for linking the library.\n") 
                                    ("\n") ("# Name of the PIC object.\n")
                                  )
                                }
                              do_expansion: True
                              here_end: EOF
                              was_filled: True
                              spids: [5929]
                            )
                          ]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:fbsd_hideous_sh_bug)
                                  op: Equal
                                  rhs: {($ VSub_Name "$base_compile")}
                                  spids: [5974]
                                )
                              ]
                              spids: [5974]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$pic_mode"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$base_compile") (" ") 
                                                ($ VSub_Name "$qsrcfile") (" ") ($ VSub_Name "$pic_flag")
                                              )
                                            }
                                          spids: [5996]
                                        )
                                      ]
                                      spids: [5996]
                                    )
                                  ]
                                  spids: [-1 5993]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:command)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_Name "$base_compile") (" ") 
                                            ($ VSub_Name "$qsrcfile")
                                          )
                                        }
                                      spids: [6013]
                                    )
                                  ]
                                  spids: [6013]
                                )
                              ]
                              spids: [6006 6021]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(KW_Bang "!")} {(-d)} 
                                          {(DQ (${ VSub_Name xdir) ($ VSub_Name "$objdir"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$mkdir") (" ") (${ VSub_Name xdir) 
                                          ($ VSub_Name "$objdir")
                                        )
                                      }
                                    )
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$mkdir")} 
                                      {(${ VSub_Name xdir) ($ VSub_Name "$objdir")}
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:exit_status)
                                          op: Equal
                                          rhs: {($ VSub_QMark "$?")}
                                          spids: [6066]
                                        )
                                      ]
                                      spids: [6066]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$exit_status"))} 
                                                      {(-ne)} {(0)}
                                                    )
                                                    (C {(test)} {(KW_Bang "!")} {(-d)} 
                                                      {
                                                        (DQ (${ VSub_Name xdir) 
                                                          ($ VSub_Name "$objdir")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(exit)} {($ VSub_Name "$exit_status")})]
                                          spids: [-1 6098]
                                        )
                                      ]
                                      spids: [-1 6106]
                                    )
                                  ]
                                  spids: [-1 6041]
                                )
                              ]
                              spids: [-1 6109]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$output_obj"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$command") (" -o ") 
                                                ($ VSub_Name "$lobj")
                                              )
                                            }
                                          spids: [6131]
                                        )
                                      ]
                                      spids: [6131]
                                    )
                                  ]
                                  spids: [-1 6124]
                                )
                              ]
                              spids: [-1 6139]
                            )
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {(DQ ($ VSub_Name "$lobj"))} 
                              {(DQ ($ VSub_Name "$output_obj"))}
                            )
                            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$command"))})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {(DQ ($ VSub_Name "$command"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(Lit_Other ":")})]
                                  spids: [-1 6175]
                                )
                              ]
                              else_action: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$output_obj"))})
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                      {($ VSub_Name "$removelist")}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                              ]
                              spids: [6180 6205]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(DQ ($ VSub_Name "$need_locks"))} 
                                              {(Lit_Other "=")} {(warn)}
                                            )
                                            (C {(test)} 
                                              {
                                                (DQ (X) 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (SimpleCommand
                                                            words: [{(cat)} {($ VSub_Name "$lockfile")}]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Great
                                                                fd: 2
                                                                arg_word: {(/dev/null)}
                                                                spids: [6233]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [6228 6235]
                                                  )
                                                )
                                              } {(KW_Bang "!") (Lit_Other "=")} {(DQ (X) ($ VSub_Name "$srcfile"))}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {
                                        (DQ ("*** ERROR, ") ($ VSub_Name "$lockfile") (" contains:\n") 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(cat)} {($ VSub_Name "$lockfile")}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [6262]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [6257 6264]
                                          ) ("\n") ("\n") ("but it should contain:\n") ($ VSub_Name "$srcfile") ("\n") ("\n") 
                                          (
"This indicates that another process is trying to use the same\n"
                                          ) ("temporary object file, and libtool could not work around it because\n") 
                                          ("your compiler does not support ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-c' and ") 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\`">
                                          ) ("-o' together.  If you\n") 
                                          (
"repeat this compilation, it may succeed, by chance, but you had better\n"
                                          ) ("avoid parallel builds (make -j) in this platform, or get a better\n") (compiler.)
                                        )
                                      }
                                    )
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                      {($ VSub_Name "$removelist")}
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [-1 6247]
                                )
                              ]
                              spids: [-1 6297]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$output_obj"))})
                                            (C {(test)} {(DQ (X) ($ VSub_Name "$output_obj"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(DQ (X) ($ VSub_Name "$lobj"))}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$mv") (" ") ($ VSub_Name "$output_obj") (" ") 
                                          ($ VSub_Name "$lobj")
                                        )
                                      }
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {($ VSub_Name "$run")} {($ VSub_Name "$mv")} 
                                                  {($ VSub_Name "$output_obj")} {($ VSub_Name "$lobj")}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 6358]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:error)
                                              op: Equal
                                              rhs: {($ VSub_QMark "$?")}
                                              spids: [6366]
                                            )
                                          ]
                                          spids: [6366]
                                        )
                                        (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                          {($ VSub_Name "$removelist")}
                                        )
                                        (C {(exit)} {($ VSub_Name "$error")})
                                      ]
                                      spids: [6363 6382]
                                    )
                                  ]
                                  spids: [-1 6333]
                                )
                              ]
                              spids: [-1 6385]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                (SimpleCommand
                                  words: [{(cat)}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_DGreat
                                      fd: -1
                                      arg_word: {(${ VSub_Name libobj) (T)}
                                      spids: [6405]
                                    )
                                    (HereDoc
                                      op_id: Redir_DLess
                                      fd: -1
                                      body: 
                                        {
                                          (DQ ("pic_object='") ($ VSub_Name "$objdir") (/) 
                                            ($ VSub_Name "$objname") ("'\n") ("\n")
                                          )
                                        }
                                      do_expansion: True
                                      here_end: EOF
                                      was_filled: True
                                      spids: [6412]
                                    )
                                  ]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$suppress_opt"))} 
                                          {(Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:suppress_output)
                                          op: Equal
                                          rhs: {(SQ <" >/dev/null 2>&1">)}
                                          spids: [6443]
                                        )
                                      ]
                                      spids: [6443]
                                    )
                                  ]
                                  spids: [-1 6440]
                                )
                              ]
                              spids: [-1 6449]
                            )
                          ]
                          spids: [-1 5967]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                            (SimpleCommand
                              words: [{(cat)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_DGreat
                                  fd: -1
                                  arg_word: {(${ VSub_Name libobj) (T)}
                                  spids: [6475]
                                )
                                (HereDoc
                                  op_id: Redir_DLess
                                  fd: -1
                                  body: {(DQ ("pic_object=none\n") ("\n"))}
                                  do_expansion: True
                                  here_end: EOF
                                  was_filled: True
                                  spids: [6482]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      spids: [6452 6488]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$pic_mode"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$base_compile") (" ") 
                                                ($ VSub_Name "$qsrcfile")
                                              )
                                            }
                                          spids: [6533]
                                        )
                                      ]
                                      spids: [6533]
                                    )
                                  ]
                                  spids: [-1 6526]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:command)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_Name "$base_compile") (" ") 
                                            ($ VSub_Name "$qsrcfile") (" ") ($ VSub_Name "$pic_flag")
                                          )
                                        }
                                      spids: [6544]
                                    )
                                  ]
                                  spids: [6544]
                                )
                              ]
                              spids: [6541 6554]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$compiler_c_o"))} 
                                          {(Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$command") (" -o ") 
                                                ($ VSub_Name "$obj")
                                              )
                                            }
                                          spids: [6573]
                                        )
                                      ]
                                      spids: [6573]
                                    )
                                  ]
                                  spids: [-1 6570]
                                )
                              ]
                              spids: [-1 6581]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:command)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$command") ($ VSub_Name "$suppress_output"))}
                                  spids: [6589]
                                )
                              ]
                              spids: [6589]
                            )
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {(DQ ($ VSub_Name "$obj"))} 
                              {(DQ ($ VSub_Name "$output_obj"))}
                            )
                            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$command"))})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {(DQ ($ VSub_Name "$command"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(Lit_Other ":")})]
                                  spids: [-1 6627]
                                )
                              ]
                              else_action: [
                                (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                  {($ VSub_Name "$removelist")}
                                )
                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                              ]
                              spids: [6632 6647]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(DQ ($ VSub_Name "$need_locks"))} 
                                              {(Lit_Other "=")} {(warn)}
                                            )
                                            (C {(test)} 
                                              {
                                                (DQ (X) 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (SimpleCommand
                                                            words: [{(cat)} {($ VSub_Name "$lockfile")}]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Great
                                                                fd: 2
                                                                arg_word: {(/dev/null)}
                                                                spids: [6675]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [6670 6677]
                                                  )
                                                )
                                              } {(KW_Bang "!") (Lit_Other "=")} {(DQ (X) ($ VSub_Name "$srcfile"))}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {
                                        (DQ ("*** ERROR, ") ($ VSub_Name "$lockfile") (" contains:\n") 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(cat)} {($ VSub_Name "$lockfile")}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [6704]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [6699 6706]
                                          ) ("\n") ("\n") ("but it should contain:\n") ($ VSub_Name "$srcfile") ("\n") ("\n") 
                                          (
"This indicates that another process is trying to use the same\n"
                                          ) ("temporary object file, and libtool could not work around it because\n") 
                                          ("your compiler does not support ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-c' and ") 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\`">
                                          ) ("-o' together.  If you\n") 
                                          (
"repeat this compilation, it may succeed, by chance, but you had better\n"
                                          ) ("avoid parallel builds (make -j) in this platform, or get a better\n") (compiler.)
                                        )
                                      }
                                    )
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                      {($ VSub_Name "$removelist")}
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [-1 6689]
                                )
                              ]
                              spids: [-1 6739]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$output_obj"))})
                                            (C {(test)} {(DQ (X) ($ VSub_Name "$output_obj"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(DQ (X) ($ VSub_Name "$obj"))}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$mv") (" ") ($ VSub_Name "$output_obj") (" ") 
                                          ($ VSub_Name "$obj")
                                        )
                                      }
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {($ VSub_Name "$run")} {($ VSub_Name "$mv")} 
                                                  {($ VSub_Name "$output_obj")} {($ VSub_Name "$obj")}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 6800]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:error)
                                              op: Equal
                                              rhs: {($ VSub_QMark "$?")}
                                              spids: [6808]
                                            )
                                          ]
                                          spids: [6808]
                                        )
                                        (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                          {($ VSub_Name "$removelist")}
                                        )
                                        (C {(exit)} {($ VSub_Name "$error")})
                                      ]
                                      spids: [6805 6824]
                                    )
                                  ]
                                  spids: [-1 6775]
                                )
                              ]
                              spids: [-1 6827]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                (SimpleCommand
                                  words: [{(cat)}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_DGreat
                                      fd: -1
                                      arg_word: {(${ VSub_Name libobj) (T)}
                                      spids: [6851]
                                    )
                                    (HereDoc
                                      op_id: Redir_DLess
                                      fd: -1
                                      body: 
                                        {
                                          (DQ ("# Name of the non-PIC object.\n") ("non_pic_object='") 
                                            ($ VSub_Name "$objname") ("'\n") ("\n")
                                          )
                                        }
                                      do_expansion: True
                                      here_end: EOF
                                      was_filled: True
                                      spids: [6858]
                                    )
                                  ]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [-1 6509]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                            (SimpleCommand
                              words: [{(cat)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_DGreat
                                  fd: -1
                                  arg_word: {(${ VSub_Name libobj) (T)}
                                  spids: [6890]
                                )
                                (HereDoc
                                  op_id: Redir_DLess
                                  fd: -1
                                  body: 
                                    {
                                      (DQ ("# Name of the non-PIC object.\n") 
                                        ("non_pic_object=none\n") ("\n")
                                      )
                                    }
                                  do_expansion: True
                                  here_end: EOF
                                  was_filled: True
                                  spids: [6897]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      spids: [6867 6904]
                    )
                    (C {($ VSub_Name "$run")} {($ VSub_Name "$mv")} {(DQ (${ VSub_Name libobj) (T))} 
                      {(DQ (${ VSub_Name libobj))}
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$need_locks"))} 
                                  {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                              {(DQ ($ VSub_Name "$lockfile"))}
                            )
                          ]
                          spids: [-1 6945]
                        )
                      ]
                      spids: [-1 6957]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                  ]
                  spids: [4087 4088 6966 -1]
                )
                (case_arm
                  pat_list: [{(link)} {(relink)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": link"))}
                          spids: [6982]
                        )
                      ]
                      spids: [6982]
                    )
                    (Case
                      to_match: {($ VSub_Name "$host")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) (Lit_Other "*")}
                            {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) (Lit_Other "*")}
                            {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) (Lit_Other "*")}
                            {(Lit_Other "*") (-) (Lit_Other "*") (-os2) (Lit_Other "*")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_undefined)
                                  op: Equal
                                  rhs: {(yes)}
                                  spids: [7069]
                                )
                              ]
                              spids: [7069]
                            )
                          ]
                          spids: [6996 7025 7073 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_undefined)
                                  op: Equal
                                  rhs: {(yes)}
                                  spids: [7080]
                                )
                              ]
                              spids: [7080]
                            )
                          ]
                          spids: [7076 7077 7084 -1]
                        )
                      ]
                      spids: [6989 6993 7087]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libtool_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [7090]
                        )
                      ]
                      spids: [7090]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base_compile)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt") (" ") ($ VSub_At "$@"))}
                          spids: [7096]
                        )
                      ]
                      spids: [7096]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:compile_command)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [7104]
                        )
                      ]
                      spids: [7104]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:finalize_command)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [7110]
                        )
                      ]
                      spids: [7110]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:compile_rpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7117]
                        )
                      ]
                      spids: [7117]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:finalize_rpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7120]
                        )
                      ]
                      spids: [7120]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:compile_shlibpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7123]
                        )
                      ]
                      spids: [7123]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:finalize_shlibpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7126]
                        )
                      ]
                      spids: [7126]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:convenience)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7129]
                        )
                      ]
                      spids: [7129]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:old_convenience)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7132]
                        )
                      ]
                      spids: [7132]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:deplibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7135]
                        )
                      ]
                      spids: [7135]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:old_deplibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7138]
                        )
                      ]
                      spids: [7138]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:compiler_flags)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7141]
                        )
                      ]
                      spids: [7141]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:linker_flags)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7144]
                        )
                      ]
                      spids: [7144]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dllsearchpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7147]
                        )
                      ]
                      spids: [7147]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:lib_search_path)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: (CommandList children:[(C {(pwd)})])
                                left_token: <Left_Backtick "`">
                                spids: [7151 7153]
                              )
                            }
                          spids: [7150]
                        )
                      ]
                      spids: [7150]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:inst_prefix_dir)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7156]
                        )
                      ]
                      spids: [7156]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:avoid_version)
                          op: Equal
                          rhs: {(no)}
                          spids: [7160]
                        )
                      ]
                      spids: [7160]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dlfiles)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7164]
                        )
                      ]
                      spids: [7164]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dlprefiles)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7167]
                        )
                      ]
                      spids: [7167]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dlself)
                          op: Equal
                          rhs: {(no)}
                          spids: [7170]
                        )
                      ]
                      spids: [7170]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:export_dynamic)
                          op: Equal
                          rhs: {(no)}
                          spids: [7174]
                        )
                      ]
                      spids: [7174]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:export_symbols)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7178]
                        )
                      ]
                      spids: [7178]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:export_symbols_regex)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7181]
                        )
                      ]
                      spids: [7181]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:generated)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7184]
                        )
                      ]
                      spids: [7184]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libobjs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7187]
                        )
                      ]
                      spids: [7187]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ltlibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7190]
                        )
                      ]
                      spids: [7190]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:module)
                          op: Equal
                          rhs: {(no)}
                          spids: [7193]
                        )
                      ]
                      spids: [7193]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_install)
                          op: Equal
                          rhs: {(no)}
                          spids: [7197]
                        )
                      ]
                      spids: [7197]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:objs) op:Equal rhs:{(SQ )} spids:[7201])]
                      spids: [7201]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:non_pic_objects)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7204]
                        )
                      ]
                      spids: [7204]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:notinst_path)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7207]
                        )
                      ]
                      spids: [7207]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:precious_files_regex)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7213]
                        )
                      ]
                      spids: [7213]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prefer_static_libs)
                          op: Equal
                          rhs: {(no)}
                          spids: [7216]
                        )
                      ]
                      spids: [7216]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preload)
                          op: Equal
                          rhs: {(no)}
                          spids: [7220]
                        )
                      ]
                      spids: [7220]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:prev) op:Equal rhs:{(SQ )} spids:[7224])]
                      spids: [7224]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prevarg)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7227]
                        )
                      ]
                      spids: [7227]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:release)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7230]
                        )
                      ]
                      spids: [7230]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7233]
                        )
                      ]
                      spids: [7233]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:xrpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7236]
                        )
                      ]
                      spids: [7236]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:perm_rpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7239]
                        )
                      ]
                      spids: [7239]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:temp_rpath)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7242]
                        )
                      ]
                      spids: [7242]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:thread_safe)
                          op: Equal
                          rhs: {(no)}
                          spids: [7245]
                        )
                      ]
                      spids: [7245]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:vinfo)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7249]
                        )
                      ]
                      spids: [7249]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:vinfo_number)
                          op: Equal
                          rhs: {(no)}
                          spids: [7252]
                        )
                      ]
                      spids: [7252]
                    )
                    (C {(func_infer_tag)} {($ VSub_Name "$base_compile")})
                    (ForEach
                      iter_name: arg
                      do_arg_iter: True
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-all-static)} {(-static)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                  {(Lit_Other "=")} {(DQ (X-all-static))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name "$build_libtool_libs")
                                                                )
                                                              } {(Lit_Other "=")} {(yes)}
                                                            )
                                                            (C {(test)} {(-z)} 
                                                              {
                                                                (DQ ($ VSub_Name "$link_static_flag"))
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": warning: complete static linking is impossible in this configuration"
                                                            )
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [7342]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [-1 7332]
                                                )
                                              ]
                                              spids: [-1 7346]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$link_static_flag"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dlopen_self)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$dlopen_self_static")}
                                                          spids: [7363]
                                                        )
                                                      ]
                                                      spids: [7363]
                                                    )
                                                  ]
                                                  spids: [-1 7360]
                                                )
                                              ]
                                              spids: [-1 7367]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prefer_static_libs)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [7370]
                                                )
                                              ]
                                              spids: [7370]
                                            )
                                          ]
                                          spids: [-1 7306]
                                        )
                                      ]
                                      else_action: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_Name "$pic_flag"))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$link_static_flag"))}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dlopen_self)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$dlopen_self_static")}
                                                      spids: [7401]
                                                    )
                                                  ]
                                                  spids: [7401]
                                                )
                                              ]
                                              spids: [-1 7398]
                                            )
                                          ]
                                          spids: [-1 7405]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:prefer_static_libs)
                                              op: Equal
                                              rhs: {(built)}
                                              spids: [7408]
                                            )
                                          ]
                                          spids: [7408]
                                        )
                                      ]
                                      spids: [7374 7412]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:build_libtool_libs)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [7415]
                                        )
                                      ]
                                      spids: [7415]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:build_old_libs)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [7419]
                                        )
                                      ]
                                      spids: [7419]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [7282 7287 7426 -1]
                                )
                              ]
                              spids: [7275 7279 7429]
                            )
                          ]
                          spids: [7272 7432]
                        )
                      spids: [-1 -1]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$old_archive_from_new_cmds"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:build_old_libs)
                              op: Equal
                              rhs: {(yes)}
                              spids: [7450]
                            )
                          ]
                          spids: [7450]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (While
                      cond: [
                        (Sentence
                          child: (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-gt)} {(0)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      body: 
                        (DoGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:arg)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [7475]
                                )
                              ]
                              spids: [7475]
                            )
                            (C {(shift)})
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\[">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\^">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\(">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\}">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\<">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\'">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                    {(DQ )}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:qarg)
                                          op: Equal
                                          rhs: 
                                            {(EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [7525 7542]
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                            }
                                          spids: [7523]
                                        )
                                      ]
                                      spids: [7523]
                                    )
                                  ]
                                  spids: [7491 7520 7549 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:qarg)
                                          op: Equal
                                          rhs: {($ VSub_Name "$arg")}
                                          spids: [7555]
                                        )
                                      ]
                                      spids: [7555]
                                    )
                                  ]
                                  spids: [7552 7553 7558 -1]
                                )
                              ]
                              spids: [7484 7488 7561]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:libtool_args)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$libtool_args") (" ") ($ VSub_Name "$qarg"))}
                                  spids: [7564]
                                )
                              ]
                              spids: [7564]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prev"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$prev")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(output)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") 
                                                        (" @OUTPUT@")
                                                      )
                                                    }
                                                  spids: [7602]
                                                )
                                              ]
                                              spids: [7602]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") 
                                                        (" @OUTPUT@")
                                                      )
                                                    }
                                                  spids: [7609]
                                                )
                                              ]
                                              spids: [7609]
                                            )
                                          ]
                                          spids: [7598 7599 7616 -1]
                                        )
                                      ]
                                      spids: [7591 7595 7619]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$prev")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(dlfiles)} {(dlprefiles)}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$preload"))} 
                                                          {(Lit_Other "=")} {(no)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:compile_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$compile_command") 
                                                                (" @SYMFILE@")
                                                              )
                                                            }
                                                          spids: [7656]
                                                        )
                                                      ]
                                                      spids: [7656]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$finalize_command") 
                                                                (" @SYMFILE@")
                                                              )
                                                            }
                                                          spids: [7663]
                                                        )
                                                      ]
                                                      spids: [7663]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:preload)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                          spids: [7670]
                                                        )
                                                      ]
                                                      spids: [7670]
                                                    )
                                                  ]
                                                  spids: [-1 7649]
                                                )
                                              ]
                                              spids: [-1 7674]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$arg")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (.la)}
                                                    {(Lit_Other "*") (.lo)}
                                                  ]
                                                  spids: [7684 7691 7693 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(force)}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$dlself"))} {(Lit_Other "=")} {(no)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:dlself)
                                                                  op: Equal
                                                                  rhs: {(needless)}
                                                                  spids: [7719]
                                                                )
                                                              ]
                                                              spids: [7719]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:export_dynamic)
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                  spids: [7723]
                                                                )
                                                              ]
                                                              spids: [7723]
                                                            )
                                                          ]
                                                          spids: [-1 7716]
                                                        )
                                                      ]
                                                      spids: [-1 7727]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:prev)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [7730]
                                                        )
                                                      ]
                                                      spids: [7730]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [7699 7700 7736 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(self)}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                                  {(Lit_Other "=")} {(dlprefiles)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:dlself)
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                  spids: [7759]
                                                                )
                                                              ]
                                                              spids: [7759]
                                                            )
                                                          ]
                                                          spids: [-1 7756]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {(DQ ($ VSub_Name "$prev"))} {(Lit_Other "=")} {(dlfiles)}
                                                                    )
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name "$dlopen_self")
                                                                        )
                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:dlself)
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                  spids: [7792]
                                                                )
                                                              ]
                                                              spids: [7792]
                                                            )
                                                          ]
                                                          spids: [7763 7789]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:dlself)
                                                              op: Equal
                                                              rhs: {(needless)}
                                                              spids: [7799]
                                                            )
                                                          ]
                                                          spids: [7799]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:export_dynamic)
                                                              op: Equal
                                                              rhs: {(yes)}
                                                              spids: [7803]
                                                            )
                                                          ]
                                                          spids: [7803]
                                                        )
                                                      ]
                                                      spids: [7796 7807]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:prev)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [7810]
                                                        )
                                                      ]
                                                      spids: [7810]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [7739 7740 7816 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                                  {(Lit_Other "=")} {(dlfiles)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:dlfiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$dlfiles") 
                                                                        (" ") ($ VSub_Name "$arg")
                                                                      )
                                                                    }
                                                                  spids: [7839]
                                                                )
                                                              ]
                                                              spids: [7839]
                                                            )
                                                          ]
                                                          spids: [-1 7836]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:dlprefiles)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$dlprefiles") 
                                                                    (" ") ($ VSub_Name "$arg")
                                                                  )
                                                                }
                                                              spids: [7850]
                                                            )
                                                          ]
                                                          spids: [7850]
                                                        )
                                                      ]
                                                      spids: [7847 7858]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:prev)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [7861]
                                                        )
                                                      ]
                                                      spids: [7861]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [7819 7820 7867 -1]
                                                )
                                              ]
                                              spids: [7677 7681 7870]
                                            )
                                          ]
                                          spids: [7630 7633 7873 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(expsyms)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:export_symbols)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [7880]
                                                )
                                              ]
                                              spids: [7880]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(KW_Bang "!")} {(-f)} 
                                                          {(DQ ($ VSub_Name "$arg"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ ($ VSub_Name "$modename") 
                                                          (": symbol file ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$arg") ("' does not exist")
                                                        )
                                                      }
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 7899]
                                                )
                                              ]
                                              spids: [-1 7918]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [7921]
                                                )
                                              ]
                                              spids: [7921]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [7876 7877 7927 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(expsyms_regex)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:export_symbols_regex)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [7934]
                                                )
                                              ]
                                              spids: [7934]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [7940]
                                                )
                                              ]
                                              spids: [7940]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [7930 7931 7946 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(inst_prefix)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:inst_prefix_dir)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [7953]
                                                )
                                              ]
                                              spids: [7953]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [7959]
                                                )
                                              ]
                                              spids: [7959]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [7949 7950 7965 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(precious_regex)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:precious_files_regex)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [7972]
                                                )
                                              ]
                                              spids: [7972]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [7978]
                                                )
                                              ]
                                              spids: [7978]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [7968 7969 7984 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(release)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:release)
                                                  op: Equal
                                                  rhs: {(DQ (-) ($ VSub_Name "$arg"))}
                                                  spids: [7991]
                                                )
                                              ]
                                              spids: [7991]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [7998]
                                                )
                                              ]
                                              spids: [7998]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [7987 7988 8004 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(objectlist)}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-f)} {(DQ ($ VSub_Name "$arg"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:save_arg)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$arg")}
                                                          spids: [8025]
                                                        )
                                                      ]
                                                      spids: [8025]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:moreargs)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [8029]
                                                        )
                                                      ]
                                                      spids: [8029]
                                                    )
                                                    (ForEach
                                                      iter_name: fil
                                                      iter_words: [
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(cat)} 
                                                                    {($ VSub_Name "$save_arg")}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [8038 8042]
                                                          )
                                                        }
                                                      ]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:arg)
                                                                  op: Equal
                                                                  rhs: {($ VSub_Name "$fil")}
                                                                  spids: [8051]
                                                                )
                                                              ]
                                                              spids: [8051]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (Subshell
                                                                          child: 
                                                                            (Pipeline
                                                                              children: [
                                                                                (C 
                                                                                  {
                                                                                    (${ VSub_Name SED)
                                                                                  } {(-e)} {(SQ <2q>)} {($ VSub_Name "$arg")}
                                                                                )
                                                                                (C {(grep)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      (
"^# Generated by .*"
                                                                                      ) ($ VSub_Name "$PACKAGE")
                                                                                    )
                                                                                  }
                                                                                )
                                                                              ]
                                                                              negated: False
                                                                            )
                                                                          redirects: [
                                                                            (Redir
                                                                              op_id: Redir_Great
                                                                              fd: -1
                                                                              arg_word: {(/dev/null)}
                                                                              spids: [8089]
                                                                            )
                                                                            (Redir
                                                                              op_id: Redir_GreatAnd
                                                                              fd: 2
                                                                              arg_word: {(1)}
                                                                              spids: [8092]
                                                                            )
                                                                          ]
                                                                          spids: [8066 8087]
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(SQ )}
                                                                          spids: [8099]
                                                                        )
                                                                      ]
                                                                      spids: [8099]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: non_pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(SQ )}
                                                                          spids: [8102]
                                                                        )
                                                                      ]
                                                                      spids: [8102]
                                                                    )
                                                                    (Case
                                                                      to_match: {($ VSub_Name "$arg")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (/) 
                                                                              (Lit_Other "*")
                                                                            }
                                                                            {(Lit_Other "*") 
                                                                              (EscapedLiteralPart
                                                                                token: 
                                                                                  <Lit_EscapedChar 
"\\\\"
                                                                                  >
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (C {(.)} 
                                                                              {($ VSub_Name "$arg")}
                                                                            )
                                                                          ]
                                                                          spids: [8121 8130 8136 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (C {(.)} 
                                                                              {(./) 
                                                                                ($ VSub_Name "$arg")
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [8139 8140 8147 -1]
                                                                        )
                                                                      ]
                                                                      spids: [8114 8118 8150]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (AndOr
                                                                                  children: [
                                                                                    (C {(test)} {(-z)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$pic_object"
                                                                                          )
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                    (AndOr
                                                                                      children: [
                                                                                        (C {(test)} 
                                                                                          {(-z)} {(DQ ($ VSub_Name "$non_pic_object"))}
                                                                                        )
                                                                                        (AndOr
                                                                                          children: [
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(DQ ($ VSub_Name "$pic_object"))} {(Lit_Other "=")} {(none)}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(DQ ($ VSub_Name "$non_pic_object"))} {(Lit_Other "=")} {(none)}
                                                                                            )
                                                                                          ]
                                                                                          op_id: 
Op_DAmp
                                                                                        )
                                                                                      ]
                                                                                      op_id: 
Op_DPipe
                                                                                    )
                                                                                  ]
                                                                                  op_id: Op_DPipe
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (SimpleCommand
                                                                              words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$echo"
                                                                                  )
                                                                                }
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$modename"
                                                                                    ) (": cannot find name of object for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                                                                    ($ VSub_Name 
"$arg"
                                                                                    ) ("'")
                                                                                  )
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (Redir
                                                                                  op_id: 
Redir_GreatAnd
                                                                                  fd: 1
                                                                                  arg_word: {(2)}
                                                                                  spids: [8217]
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {(exit)} 
                                                                              {
                                                                                ($ VSub_Name 
"$EXIT_FAILURE"
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [-1 8204]
                                                                        )
                                                                      ]
                                                                      spids: [-1 8226]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:xdir)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) ($ VSub_Name "$arg"))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(SQ <"s%/[^/]*$%%">)}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [8235 8252]
                                                                              )
                                                                            }
                                                                          spids: [8234]
                                                                        )
                                                                      ]
                                                                      spids: [8234]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ (X) 
                                                                                      ($ VSub_Name 
"$xdir"
                                                                                      )
                                                                                    )
                                                                                  } {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$arg"))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: xdir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(SQ )}
                                                                                  spids: [8275]
                                                                                )
                                                                              ]
                                                                              spids: [8275]
                                                                            )
                                                                          ]
                                                                          spids: [-1 8272]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: xdir
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$xdir"
                                                                                    ) (/)
                                                                                  )
                                                                                }
                                                                              spids: [8281]
                                                                            )
                                                                          ]
                                                                          spids: [8281]
                                                                        )
                                                                      ]
                                                                      spids: [8278 8288]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$pic_object"
                                                                                      )
                                                                                    )
                                                                                  } {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
pic_object
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$xdir"
                                                                                        ) ($ VSub_Name "$pic_object")
                                                                                      )
                                                                                    }
                                                                                  spids: [8313]
                                                                                )
                                                                              ]
                                                                              spids: [8313]
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {
                                                                                            (DQ 
                                                                                              ($ 
VSub_Name "$prev"
                                                                                              )
                                                                                            )
                                                                                          } {(Lit_Other "=")} {(dlfiles)}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (AndOr
                                                                                                  children: [
                                                                                                    (C 
                                                                                                      {
                                                                                                        (
test
                                                                                                        )
                                                                                                      } {(DQ ($ VSub_Name "$build_libtool_libs"))} {(Lit_Other "=")} {(yes)}
                                                                                                    )
                                                                                                    (C 
                                                                                                      {
                                                                                                        (
test
                                                                                                        )
                                                                                                      } {(DQ ($ VSub_Name "$dlopen_support"))} {(Lit_Other "=")} {(yes)}
                                                                                                    )
                                                                                                  ]
                                                                                                  op_id: 
Op_DAmp
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
dlfiles
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (DQ 
                                                                                                        ($ 
VSub_Name "$dlfiles"
                                                                                                        ) (" ") ($ VSub_Name "$pic_object")
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
8365
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
8365
                                                                                              ]
                                                                                            )
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
prev
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: {(SQ )}
                                                                                                  spids: [
8373
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
8373
                                                                                              ]
                                                                                            )
                                                                                            (ControlFlow
                                                                                              token: 
                                                                                                <
ControlFlow_Continue continue
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
8362
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      else_action: [
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
prev
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (
dlprefiles
                                                                                                  )
                                                                                                }
                                                                                              spids: [
8386
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
8386
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
8379
8390
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 8334]
                                                                                )
                                                                              ]
                                                                              spids: [-1 8393]
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {
                                                                                            (DQ 
                                                                                              ($ 
VSub_Name "$prev"
                                                                                              )
                                                                                            )
                                                                                          } {(Lit_Other "=")} {(dlprefiles)}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
dlprefiles
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$dlprefiles"
                                                                                                ) (" ") ($ VSub_Name "$pic_object")
                                                                                              )
                                                                                            }
                                                                                          spids: [
8421
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [8421]
                                                                                    )
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
prev
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: {(SQ )}
                                                                                          spids: [
8429
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [8429]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 8414]
                                                                                )
                                                                              ]
                                                                              spids: [-1 8432]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: libobjs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$libobjs"
                                                                                        ) (" ") ($ VSub_Name "$pic_object")
                                                                                      )
                                                                                    }
                                                                                  spids: [8440]
                                                                                )
                                                                              ]
                                                                              spids: [8440]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: arg
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$pic_object"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [8448]
                                                                                )
                                                                              ]
                                                                              spids: [8448]
                                                                            )
                                                                          ]
                                                                          spids: [-1 8306]
                                                                        )
                                                                      ]
                                                                      spids: [-1 8454]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$non_pic_object"
                                                                                      )
                                                                                    )
                                                                                  } {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
non_pic_object
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$xdir"
                                                                                        ) ($ VSub_Name "$non_pic_object")
                                                                                      )
                                                                                    }
                                                                                  spids: [8483]
                                                                                )
                                                                              ]
                                                                              spids: [8483]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
non_pic_objects
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$non_pic_objects"
                                                                                        ) (" ") ($ VSub_Name "$non_pic_object")
                                                                                      )
                                                                                    }
                                                                                  spids: [8495]
                                                                                )
                                                                              ]
                                                                              spids: [8495]
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (AndOr
                                                                                          children: [
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(-z)} {(DQ ($ VSub_Name "$pic_object"))}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(DQ ($ VSub_Name "$pic_object"))} {(Lit_Other "=")} {(none)}
                                                                                            )
                                                                                          ]
                                                                                          op_id: 
Op_DPipe
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
arg
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$non_pic_object"
                                                                                                )
                                                                                              )
                                                                                            }
                                                                                          spids: [
8530
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [8530]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 8527]
                                                                                )
                                                                              ]
                                                                              spids: [-1 8536]
                                                                            )
                                                                          ]
                                                                          spids: [-1 8476]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: 
non_pic_object
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$pic_object"
                                                                                    )
                                                                                  )
                                                                                }
                                                                              spids: [8550]
                                                                            )
                                                                          ]
                                                                          spids: [8550]
                                                                        )
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: 
non_pic_objects
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$non_pic_objects"
                                                                                    ) (" ") ($ VSub_Name "$non_pic_object")
                                                                                  )
                                                                                }
                                                                              spids: [8556]
                                                                            )
                                                                          ]
                                                                          spids: [8556]
                                                                        )
                                                                      ]
                                                                      spids: [8539 8564]
                                                                    )
                                                                  ]
                                                                  spids: [-1 8096]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (If
                                                                  arms: [
                                                                    (if_arm
                                                                      cond: [
                                                                        (Sentence
                                                                          child: 
                                                                            (C {(test)} {(-z)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name "$run")
                                                                                )
                                                                              }
                                                                            )
                                                                          terminator: <Op_Semi ";">
                                                                        )
                                                                      ]
                                                                      action: [
                                                                        (SimpleCommand
                                                                          words: [
                                                                            {($ VSub_Name "$echo")}
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$modename"
                                                                                ) (": ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$arg") 
                                                                                (
"' is not a valid libtool object"
                                                                                )
                                                                              )
                                                                            }
                                                                          ]
                                                                          redirects: [
                                                                            (Redir
                                                                              op_id: Redir_GreatAnd
                                                                              fd: 1
                                                                              arg_word: {(2)}
                                                                              spids: [8598]
                                                                            )
                                                                          ]
                                                                        )
                                                                        (C {(exit)} 
                                                                          {
                                                                            ($ VSub_Name 
"$EXIT_FAILURE"
                                                                            )
                                                                          }
                                                                        )
                                                                      ]
                                                                      spids: [-1 8585]
                                                                    )
                                                                  ]
                                                                  else_action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:xdir)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) ($ VSub_Name "$arg"))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(SQ <"s%/[^/]*$%%">)}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [8620 8637]
                                                                              )
                                                                            }
                                                                          spids: [8619]
                                                                        )
                                                                      ]
                                                                      spids: [8619]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ (X) 
                                                                                      ($ VSub_Name 
"$xdir"
                                                                                      )
                                                                                    )
                                                                                  } {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$arg"))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: xdir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(SQ )}
                                                                                  spids: [8660]
                                                                                )
                                                                              ]
                                                                              spids: [8660]
                                                                            )
                                                                          ]
                                                                          spids: [-1 8657]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: xdir
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$xdir"
                                                                                    ) (/)
                                                                                  )
                                                                                }
                                                                              spids: [8666]
                                                                            )
                                                                          ]
                                                                          spids: [8666]
                                                                        )
                                                                      ]
                                                                      spids: [8663 8673]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) (${ VSub_Name xdir) (${ VSub_Name objdir) (/) (${ VSub_Name arg))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(DQ ($ VSub_Name "$lo2o"))}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [8678 8704]
                                                                              )
                                                                            }
                                                                          spids: [8677]
                                                                        )
                                                                      ]
                                                                      spids: [8677]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: non_pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) (${ VSub_Name xdir) (${ VSub_Name arg))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(DQ ($ VSub_Name "$lo2o"))}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [8708 8730]
                                                                              )
                                                                            }
                                                                          spids: [8707]
                                                                        )
                                                                      ]
                                                                      spids: [8707]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:libobjs)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$libobjs"
                                                                                ) (" ") ($ VSub_Name "$pic_object")
                                                                              )
                                                                            }
                                                                          spids: [8733]
                                                                        )
                                                                      ]
                                                                      spids: [8733]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: non_pic_objects
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$non_pic_objects"
                                                                                ) (" ") ($ VSub_Name "$non_pic_object")
                                                                              )
                                                                            }
                                                                          spids: [8741]
                                                                        )
                                                                      ]
                                                                      spids: [8741]
                                                                    )
                                                                  ]
                                                                  spids: [8607 8749]
                                                                )
                                                              ]
                                                              spids: [8567 8752]
                                                            )
                                                          ]
                                                          spids: [8045 8755]
                                                        )
                                                      spids: [8037 -1]
                                                    )
                                                  ]
                                                  spids: [-1 8022]
                                                )
                                              ]
                                              else_action: [
                                                (C {($ VSub_Name "$echo")} 
                                                  {
                                                    (DQ ($ VSub_Name "$modename") 
                                                      (": link input file ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$save_arg") ("' does not exist")
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                              ]
                                              spids: [8758 8777]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$save_arg")}
                                                  spids: [8780]
                                                )
                                              ]
                                              spids: [8780]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [8784]
                                                )
                                              ]
                                              spids: [8784]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [8007 8008 8790 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(rpath)} {(xrpath)}]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$arg")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "[") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (/) (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "[") (A-Za-z) (Lit_Other "]") 
                                                      (Lit_Other ":") (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [8812 8829 8831 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": only absolute run-paths are allowed"
                                                            )
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [8845]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [8834 8835 8854 -1]
                                                )
                                              ]
                                              spids: [8805 8809 8857]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                          {(Lit_Other "=")} {(rpath)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Case
                                                      to_match: {(DQ ($ VSub_Name "$rpath") (" "))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$arg") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [8886 8893 8895 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:rpath)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$rpath") (" ") 
                                                                        ($ VSub_Name "$arg")
                                                                      )
                                                                    }
                                                                  spids: [8901]
                                                                )
                                                              ]
                                                              spids: [8901]
                                                            )
                                                          ]
                                                          spids: [8898 8899 8908 -1]
                                                        )
                                                      ]
                                                      spids: [8876 8883 8911]
                                                    )
                                                  ]
                                                  spids: [-1 8873]
                                                )
                                              ]
                                              else_action: [
                                                (Case
                                                  to_match: {(DQ ($ VSub_Name "$xrpath") (" "))}
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Other "*") 
                                                          (DQ (" ") ($ VSub_Name "$arg") (" ")) (Lit_Other "*")
                                                        }
                                                      ]
                                                      spids: [8927 8934 8936 -1]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Other "*")}]
                                                      action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:xrpath)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$xrpath") (" ") 
                                                                    ($ VSub_Name "$arg")
                                                                  )
                                                                }
                                                              spids: [8942]
                                                            )
                                                          ]
                                                          spids: [8942]
                                                        )
                                                      ]
                                                      spids: [8939 8940 8949 -1]
                                                    )
                                                  ]
                                                  spids: [8917 8924 8952]
                                                )
                                              ]
                                              spids: [8914 8955]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [8958]
                                                )
                                              ]
                                              spids: [8958]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [8793 8798 8964 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(xcompiler)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [8971]
                                                )
                                              ]
                                              spids: [8971]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [8979]
                                                )
                                              ]
                                              spids: [8979]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [8982]
                                                )
                                              ]
                                              spids: [8982]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [8990]
                                                )
                                              ]
                                              spids: [8990]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [8967 8968 9001 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(xlinker)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linker_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$linker_flags") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9008]
                                                )
                                              ]
                                              spids: [9008]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9016]
                                                )
                                              ]
                                              spids: [9016]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [9025]
                                                )
                                              ]
                                              spids: [9025]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9028]
                                                )
                                              ]
                                              spids: [9028]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9037]
                                                )
                                              ]
                                              spids: [9037]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [9004 9005 9049 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(xcclinker)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linker_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$linker_flags") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9056]
                                                )
                                              ]
                                              spids: [9056]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9064]
                                                )
                                              ]
                                              spids: [9064]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [9072]
                                                )
                                              ]
                                              spids: [9072]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9075]
                                                )
                                              ]
                                              spids: [9075]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$qarg")
                                                      )
                                                    }
                                                  spids: [9083]
                                                )
                                              ]
                                              spids: [9083]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [9052 9053 9094 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(shrext)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:shrext_cmds)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                                  spids: [9101]
                                                )
                                              ]
                                              spids: [9101]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [9107]
                                                )
                                              ]
                                              spids: [9107]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [9097 9098 9113 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(darwin_framework)} {(darwin_framework_skip)}]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                  {(Lit_Other "=")} {(DQ (darwin_framework))}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:compiler_flags)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                            ($ VSub_Name "$arg")
                                                          )
                                                        }
                                                      spids: [9136]
                                                    )
                                                  ]
                                                  spids: [9136]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [9144]
                                                )
                                              ]
                                              spids: [9144]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [9152]
                                                )
                                              ]
                                              spids: [9152]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [9160]
                                                )
                                              ]
                                              spids: [9160]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [9116 9119 9166 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (C {(eval)} 
                                              {
                                                (DQ ($ VSub_Name "$prev") ("=") 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\\"">
                                                  ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (arg) 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\\"">
                                                  )
                                                )
                                              }
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [9185]
                                                )
                                              ]
                                              spids: [9185]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [9169 9170 9191 -1]
                                        )
                                      ]
                                      spids: [7623 7627 9194]
                                    )
                                  ]
                                  spids: [-1 7588]
                                )
                              ]
                              spids: [-1 9197]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:prevarg)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$arg"))}
                                  spids: [9204]
                                )
                              ]
                              spids: [9204]
                            )
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-all-static)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_Name "$link_static_flag"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$link_static_flag")
                                                      )
                                                    }
                                                  spids: [9236]
                                                )
                                              ]
                                              spids: [9236]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$link_static_flag")
                                                      )
                                                    }
                                                  spids: [9244]
                                                )
                                              ]
                                              spids: [9244]
                                            )
                                          ]
                                          spids: [-1 9233]
                                        )
                                      ]
                                      spids: [-1 9252]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9218 9219 9258 -1]
                                )
                                (case_arm
                                  pat_list: [{(-allow-undefined)}]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-allow-undefined' is deprecated because it is the default")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [9279]
                                        )
                                      ]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9262 9263 9286 -1]
                                )
                                (case_arm
                                  pat_list: [{(-avoid-version)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:avoid_version)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [9294]
                                        )
                                      ]
                                      spids: [9294]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9290 9291 9301 -1]
                                )
                                (case_arm
                                  pat_list: [{(-dlopen)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(dlfiles)}
                                          spids: [9309]
                                        )
                                      ]
                                      spids: [9309]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9305 9306 9316 -1]
                                )
                                (case_arm
                                  pat_list: [{(-dlpreopen)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(dlprefiles)}
                                          spids: [9324]
                                        )
                                      ]
                                      spids: [9324]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9320 9321 9331 -1]
                                )
                                (case_arm
                                  pat_list: [{(-export-dynamic)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:export_dynamic)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [9339]
                                        )
                                      ]
                                      spids: [9339]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9335 9336 9346 -1]
                                )
                                (case_arm
                                  pat_list: [{(-export-symbols)} {(-export-symbols-regex)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$export_symbols"))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$export_symbols_regex"))}
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$echo")} 
                                              {
                                                (DQ ($ VSub_Name "$modename") 
                                                  (
": more than one -exported-symbols argument is not allowed"
                                                  )
                                                )
                                              }
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [-1 9379]
                                        )
                                      ]
                                      spids: [-1 9395]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                  {(Lit_Other "=")} {(DQ (X-export-symbols))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(expsyms)}
                                                  spids: [9417]
                                                )
                                              ]
                                              spids: [9417]
                                            )
                                          ]
                                          spids: [-1 9414]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:prev)
                                              op: Equal
                                              rhs: {(expsyms_regex)}
                                              spids: [9424]
                                            )
                                          ]
                                          spids: [9424]
                                        )
                                      ]
                                      spids: [9421 9428]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9350 9355 9434 -1]
                                )
                                (case_arm
                                  pat_list: [{(-framework)} {(-arch)} {(-isysroot)}]
                                  action: [
                                    (Case
                                      to_match: {(DQ (" ") ($ VSub_Name "$CC") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") 
                                              (DQ (" ") (${ VSub_Name arg) (" ") (${ VSub_Number 1) (" ")) (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") 
                                              (DQ (" ") (${ VSub_Name arg) ("\t") (${ VSub_Number 1) 
                                                (" ")
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(darwin_framework_skip)}
                                                  spids: [9490]
                                                )
                                              ]
                                              spids: [9490]
                                            )
                                          ]
                                          spids: [9457 9486 9493 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [9499]
                                                )
                                              ]
                                              spids: [9499]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(darwin_framework)}
                                                  spids: [9507]
                                                )
                                              ]
                                              spids: [9507]
                                            )
                                          ]
                                          spids: [9496 9497 9510 -1]
                                        )
                                      ]
                                      spids: [9446 9454 9513]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [9516]
                                        )
                                      ]
                                      spids: [9516]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [9524]
                                        )
                                      ]
                                      spids: [9524]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9438 9443 9535 -1]
                                )
                                (case_arm
                                  pat_list: [{(-inst-prefix-dir)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(inst_prefix)}
                                          spids: [9543]
                                        )
                                      ]
                                      spids: [9543]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9539 9540 9550 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {(-L) (Lit_Other "[") (A-Z) (Lit_Other "]") (Lit_Other "[") (A-Z) 
                                      (Lit_Other "]") (Lit_Other "*") (Lit_Other ":") (Lit_Other "*")
                                    }
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$with_gcc") (/) ($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(no/) (Lit_Other "*") (-) (Lit_Other "*") (-irix) 
                                              (Lit_Other "*")
                                            }
                                            {(/) (Lit_Other "*") (-) (Lit_Other "*") (-irix) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [9602]
                                                )
                                              ]
                                              spids: [9602]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [9610]
                                                )
                                              ]
                                              spids: [9610]
                                            )
                                          ]
                                          spids: [9584 9599 9618 -1]
                                        )
                                      ]
                                      spids: [9575 9581 9621]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9562 9572 9627 -1]
                                )
                                (case_arm
                                  pat_list: [{(-L) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/^-L//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [9637 9654]
                                              )
                                            }
                                          spids: [9636]
                                        )
                                      ]
                                      spids: [9636]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$dir")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") 
                                              (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                          ]
                                          spids: [9668 9685 9687 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:absdir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (AndOr
                                                                children: [
                                                                  (C {(cd)} {(DQ ($ VSub_Name "$dir"))})
                                                                  (C {(pwd)})
                                                                ]
                                                                op_id: Op_DAmp
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [9695 9705]
                                                      )
                                                    }
                                                  spids: [9694]
                                                )
                                              ]
                                              spids: [9694]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$absdir"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": cannot determine absolute directory name of "
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$dir") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [9732]
                                                        )
                                                      ]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:absdir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$dir"))}
                                                          spids: [9736]
                                                        )
                                                      ]
                                                      spids: [9736]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:notinst_path)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$notinst_path") (" ") 
                                                                ($ VSub_Name "$dir")
                                                              )
                                                            }
                                                          spids: [9742]
                                                        )
                                                      ]
                                                      spids: [9742]
                                                    )
                                                  ]
                                                  spids: [-1 9719]
                                                )
                                              ]
                                              spids: [-1 9750]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dir)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$absdir"))}
                                                  spids: [9753]
                                                )
                                              ]
                                              spids: [9753]
                                            )
                                          ]
                                          spids: [9690 9691 9759 -1]
                                        )
                                      ]
                                      spids: [9661 9665 9762]
                                    )
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$deplibs") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" -L") ($ VSub_Name "$dir") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          spids: [9775 9782 9784 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$deplibs") (" -L") 
                                                        ($ VSub_Name "$dir")
                                                      )
                                                    }
                                                  spids: [9791]
                                                )
                                              ]
                                              spids: [9791]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lib_search_path)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$lib_search_path") (" ") 
                                                        ($ VSub_Name "$dir")
                                                      )
                                                    }
                                                  spids: [9799]
                                                )
                                              ]
                                              spids: [9799]
                                            )
                                          ]
                                          spids: [9787 9788 9807 -1]
                                        )
                                      ]
                                      spids: [9765 9772 9810]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-os2) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:testbindir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$dir"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s*/lib$*/bin*">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [9853 9870]
                                                      )
                                                    }
                                                  spids: [9852]
                                                )
                                              ]
                                              spids: [9852]
                                            )
                                            (Case
                                              to_match: 
                                                {(Lit_Other ":") ($ VSub_Name "$dllsearchpath") 
                                                  (Lit_Other ":")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (":") ($ VSub_Name "$dir") (":")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [9882 9889 9891 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dllsearchpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dllsearchpath") (":") 
                                                                ($ VSub_Name "$dir")
                                                              )
                                                            }
                                                          spids: [9897]
                                                        )
                                                      ]
                                                      spids: [9897]
                                                    )
                                                  ]
                                                  spids: [9894 9895 9903 -1]
                                                )
                                              ]
                                              spids: [9873 9879 9906]
                                            )
                                            (Case
                                              to_match: 
                                                {(Lit_Other ":") ($ VSub_Name "$dllsearchpath") 
                                                  (Lit_Other ":")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (":") ($ VSub_Name "$testbindir") (":")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [9918 9925 9927 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dllsearchpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dllsearchpath") (":") 
                                                                ($ VSub_Name "$testbindir")
                                                              )
                                                            }
                                                          spids: [9933]
                                                        )
                                                      ]
                                                      spids: [9933]
                                                    )
                                                  ]
                                                  spids: [9930 9931 9939 -1]
                                                )
                                              ]
                                              spids: [9909 9915 9942]
                                            )
                                          ]
                                          spids: [9820 9849 9945 -1]
                                        )
                                      ]
                                      spids: [9813 9817 9948]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9631 9633 9954 -1]
                                )
                                (case_arm
                                  pat_list: [{(-l) (Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                      {(Lit_Other "=")} {(DQ (X-lc))}
                                                    )
                                                    (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                      {(Lit_Other "=")} {(DQ (X-lm))}
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$host")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-beos) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [10004 10033 10043 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-os2) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                          {(Lit_Other "=")} {(DQ (X-lc))}
                                                        )
                                                        (ControlFlow
                                                          token: <ControlFlow_Continue continue>
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  spids: [10046 10051 10076 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-openbsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-freebsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-dragonfly) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                          {(Lit_Other "=")} {(DQ (X-lc))}
                                                        )
                                                        (ControlFlow
                                                          token: <ControlFlow_Continue continue>
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  spids: [10079 10100 10125 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-rhapsody) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-darwin1.) 
                                                      (Lit_Other "[") (012) (Lit_Other "]")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplibs") 
                                                                (" -framework System")
                                                              )
                                                            }
                                                          spids: [10150]
                                                        )
                                                      ]
                                                      spids: [10150]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [10128 10143 10160 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sco3.2v5) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sco5v6) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                          {(Lit_Other "=")} {(DQ (X-lc))}
                                                        )
                                                        (ControlFlow
                                                          token: <ControlFlow_Continue continue>
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  spids: [10163 10176 10201 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sysv4.2uw2) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sysv5) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-unixware) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-OpenUNIX) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                          {(Lit_Other "=")} {(DQ (X-lc))}
                                                        )
                                                        (ControlFlow
                                                          token: <ControlFlow_Continue continue>
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  spids: [10204 10233 10258 -1]
                                                )
                                              ]
                                              spids: [9997 10001 10261]
                                            )
                                          ]
                                          spids: [-1 9994]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$arg"))} 
                                                  {(Lit_Other "=")} {(DQ (X-lc_r))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$host")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-openbsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-freebsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-dragonfly) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [10290 10311 10321 -1]
                                                )
                                              ]
                                              spids: [10283 10287 10324]
                                            )
                                          ]
                                          spids: [10264 10280]
                                        )
                                      ]
                                      spids: [-1 10327]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$deplibs") (" ") ($ VSub_Name "$arg"))
                                            }
                                          spids: [10330]
                                        )
                                      ]
                                      spids: [10330]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [9958 9960 10341 -1]
                                )
                                (case_arm
                                  pat_list: [{(-model)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10357]
                                        )
                                      ]
                                      spids: [10357]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compiler_flags)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10365]
                                        )
                                      ]
                                      spids: [10365]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10373]
                                        )
                                      ]
                                      spids: [10373]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(xcompiler)}
                                          spids: [10381]
                                        )
                                      ]
                                      spids: [10381]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10353 10354 10388 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {(-mt)}
                                    {(-mthreads)}
                                    {(-kthread)}
                                    {(-Kthread)}
                                    {(-pthread)}
                                    {(-pthreads)}
                                    {(--thread-safe)}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compiler_flags)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10408]
                                        )
                                      ]
                                      spids: [10408]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10416]
                                        )
                                      ]
                                      spids: [10416]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10424]
                                        )
                                      ]
                                      spids: [10424]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10392 10405 10435 -1]
                                )
                                (case_arm
                                  pat_list: [{(-module)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:module)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [10443]
                                        )
                                      ]
                                      spids: [10443]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10439 10440 10450 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {(-64)}
                                    {(-mips) (Lit_Other "[") (0-9) (Lit_Other "]")}
                                    {(-r) (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(-xarch) (Lit_Other "=") (Lit_Other "*")}
                                    {(-xtarget) (Lit_Other "=") (Lit_Other "*")}
                                    {(Lit_Other "+") (DA) (Lit_Other "*")}
                                    {(Lit_Other "+") (DD) (Lit_Other "*")}
                                    {(-q) (Lit_Other "*")}
                                    {(-m) (Lit_Other "*")}
                                    {(-pg)}
                                    {(-t) (Lit_Other "[") (45) (Lit_Other "]") (Lit_Other "*")}
                                    {(-txscale) (Lit_Other "*")}
                                    {(Lit_Other "@") (Lit_Other "*")}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [10561 10578]
                                              )
                                            }
                                          spids: [10560]
                                        )
                                      ]
                                      spids: [10560]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$arg")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\[">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\^">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\(">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\}">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\<">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\'">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                              (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                            {(DQ )}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      )
                                                    }
                                                  spids: [10620]
                                                )
                                              ]
                                              spids: [10620]
                                            )
                                          ]
                                          spids: [10588 10617 10628 -1]
                                        )
                                      ]
                                      spids: [10581 10585 10631]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10634]
                                        )
                                      ]
                                      spids: [10634]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10642]
                                        )
                                      ]
                                      spids: [10642]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compiler_flags)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [10650]
                                        )
                                      ]
                                      spids: [10650]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10494 10548 10661 -1]
                                )
                                (case_arm
                                  pat_list: [{(-shrext)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(shrext)}
                                          spids: [10669]
                                        )
                                      ]
                                      spids: [10669]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10665 10666 10676 -1]
                                )
                                (case_arm
                                  pat_list: [{(-no-fast-install)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:fast_install)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [10684]
                                        )
                                      ]
                                      spids: [10684]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10680 10681 10691 -1]
                                )
                                (case_arm
                                  pat_list: [{(-no-install)}]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-os2) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": warning: ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("-no-install' is ignored for ") ($ VSub_Name "$host")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [10756]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": warning: assuming ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-no-fast-install' instead")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [10769]
                                                )
                                              ]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:fast_install)
                                                  op: Equal
                                                  rhs: {(no)}
                                                  spids: [10773]
                                                )
                                              ]
                                              spids: [10773]
                                            )
                                          ]
                                          spids: [10706 10735 10777 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:no_install)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [10783]
                                                )
                                              ]
                                              spids: [10783]
                                            )
                                          ]
                                          spids: [10780 10781 10786 -1]
                                        )
                                      ]
                                      spids: [10699 10703 10789]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10695 10696 10795 -1]
                                )
                                (case_arm
                                  pat_list: [{(-no-undefined)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:allow_undefined)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [10803]
                                        )
                                      ]
                                      spids: [10803]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10799 10800 10810 -1]
                                )
                                (case_arm
                                  pat_list: [{(-objectlist)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(objectlist)}
                                          spids: [10818]
                                        )
                                      ]
                                      spids: [10818]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10814 10815 10825 -1]
                                )
                                (case_arm
                                  pat_list: [{(-o)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(output)}
                                          spids: [10832]
                                        )
                                      ]
                                      spids: [10832]
                                    )
                                  ]
                                  spids: [10829 10830 10835 -1]
                                )
                                (case_arm
                                  pat_list: [{(-precious-files-regex)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(precious_regex)}
                                          spids: [10843]
                                        )
                                      ]
                                      spids: [10843]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10839 10840 10850 -1]
                                )
                                (case_arm
                                  pat_list: [{(-release)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(release)}
                                          spids: [10858]
                                        )
                                      ]
                                      spids: [10858]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10854 10855 10865 -1]
                                )
                                (case_arm
                                  pat_list: [{(-rpath)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(rpath)}
                                          spids: [10873]
                                        )
                                      ]
                                      spids: [10873]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10869 10870 10880 -1]
                                )
                                (case_arm
                                  pat_list: [{(-R)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(xrpath)}
                                          spids: [10888]
                                        )
                                      ]
                                      spids: [10888]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10884 10885 10895 -1]
                                )
                                (case_arm
                                  pat_list: [{(-R) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/^-R//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [10905 10922]
                                              )
                                            }
                                          spids: [10904]
                                        )
                                      ]
                                      spids: [10904]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$dir")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") 
                                              (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                          ]
                                          spids: [10936 10953 10955 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": only absolute run-paths are allowed")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [10969]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [10958 10959 10978 -1]
                                        )
                                      ]
                                      spids: [10929 10933 10981]
                                    )
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$xrpath") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$dir") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          spids: [10994 11001 11003 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:xrpath)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$xrpath") (" ") 
                                                        ($ VSub_Name "$dir")
                                                      )
                                                    }
                                                  spids: [11009]
                                                )
                                              ]
                                              spids: [11009]
                                            )
                                          ]
                                          spids: [11006 11007 11016 -1]
                                        )
                                      ]
                                      spids: [10984 10991 11019]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [10899 10901 11025 -1]
                                )
                                (case_arm
                                  pat_list: [{(-static)}]
                                  action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                                  spids: [11029 11030 11056 -1]
                                )
                                (case_arm
                                  pat_list: [{(-thread-safe)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:thread_safe)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [11064]
                                        )
                                      ]
                                      spids: [11064]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11060 11061 11071 -1]
                                )
                                (case_arm
                                  pat_list: [{(-version-info)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(vinfo)}
                                          spids: [11079]
                                        )
                                      ]
                                      spids: [11079]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11075 11076 11086 -1]
                                )
                                (case_arm
                                  pat_list: [{(-version-number)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(vinfo)}
                                          spids: [11093]
                                        )
                                      ]
                                      spids: [11093]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:vinfo_number)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [11097]
                                        )
                                      ]
                                      spids: [11097]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11089 11090 11104 -1]
                                )
                                (case_arm
                                  pat_list: [{(-Wc) (Lit_Comma ",") (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:args)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))} {(-e)} {(SQ <"s/^-Wc,//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [11115 11138]
                                              )
                                            }
                                          spids: [11114]
                                        )
                                      ]
                                      spids: [11114]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [11141]
                                        )
                                      ]
                                      spids: [11141]
                                    )
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:save_ifs)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$IFS"))}
                                              spids: [11144]
                                            )
                                          ]
                                          spids: [11144]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(SQ <",">)}
                                          spids: [11150]
                                        )
                                      ]
                                      spids: [11150]
                                    )
                                    (ForEach
                                      iter_name: flag
                                      iter_words: [{($ VSub_Name "$args")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [11168]
                                                )
                                              ]
                                              spids: [11168]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$flag")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (Lit_Other "[") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\[">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\^">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\(">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\}">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\<">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\'">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                                      (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                                    {(DQ )}
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:flag)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$flag") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              )
                                                            }
                                                          spids: [11213]
                                                        )
                                                      ]
                                                      spids: [11213]
                                                    )
                                                  ]
                                                  spids: [11181 11210 11221 -1]
                                                )
                                              ]
                                              spids: [11174 11178 11224]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$arg") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [11227]
                                                )
                                              ]
                                              spids: [11227]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [11236]
                                                )
                                              ]
                                              spids: [11236]
                                            )
                                          ]
                                          spids: [11165 11244]
                                        )
                                      spids: [11161 11163]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [11247]
                                        )
                                      ]
                                      spids: [11247]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ("s/^ //"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [11254 11271]
                                              )
                                            }
                                          spids: [11253]
                                        )
                                      ]
                                      spids: [11253]
                                    )
                                  ]
                                  spids: [11108 11111 11274 -1]
                                )
                                (case_arm
                                  pat_list: [{(-Wl) (Lit_Comma ",") (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:args)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))} {(-e)} {(SQ <"s/^-Wl,//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [11285 11308]
                                              )
                                            }
                                          spids: [11284]
                                        )
                                      ]
                                      spids: [11284]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [11311]
                                        )
                                      ]
                                      spids: [11311]
                                    )
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:save_ifs)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$IFS"))}
                                              spids: [11314]
                                            )
                                          ]
                                          spids: [11314]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(SQ <",">)}
                                          spids: [11320]
                                        )
                                      ]
                                      spids: [11320]
                                    )
                                    (ForEach
                                      iter_name: flag
                                      iter_words: [{($ VSub_Name "$args")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [11338]
                                                )
                                              ]
                                              spids: [11338]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$flag")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (Lit_Other "[") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\[">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\^">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\(">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\}">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\<">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\'">
                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                                      (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                                    {(DQ )}
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:flag)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$flag") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              )
                                                            }
                                                          spids: [11383]
                                                        )
                                                      ]
                                                      spids: [11383]
                                                    )
                                                  ]
                                                  spids: [11351 11380 11391 -1]
                                                )
                                              ]
                                              spids: [11344 11348 11394]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$arg") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [11397]
                                                )
                                              ]
                                              spids: [11397]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compiler_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                        ($ VSub_Name "$wl") ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [11406]
                                                )
                                              ]
                                              spids: [11406]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linker_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$linker_flags") (" ") 
                                                        ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [11415]
                                                )
                                              ]
                                              spids: [11415]
                                            )
                                          ]
                                          spids: [11335 11423]
                                        )
                                      spids: [11331 11333]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [11426]
                                        )
                                      ]
                                      spids: [11426]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ("s/^ //"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [11433 11450]
                                              )
                                            }
                                          spids: [11432]
                                        )
                                      ]
                                      spids: [11432]
                                    )
                                  ]
                                  spids: [11278 11281 11453 -1]
                                )
                                (case_arm
                                  pat_list: [{(-Xcompiler)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(xcompiler)}
                                          spids: [11461]
                                        )
                                      ]
                                      spids: [11461]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11457 11458 11468 -1]
                                )
                                (case_arm
                                  pat_list: [{(-Xlinker)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(xlinker)}
                                          spids: [11476]
                                        )
                                      ]
                                      spids: [11476]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11472 11473 11483 -1]
                                )
                                (case_arm
                                  pat_list: [{(-XCClinker)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {(xcclinker)}
                                          spids: [11491]
                                        )
                                      ]
                                      spids: [11491]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [11487 11488 11498 -1]
                                )
                                (case_arm
                                  pat_list: [{(-) (Lit_Other "*")} {(Lit_Other "+") (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [11525 11542]
                                              )
                                            }
                                          spids: [11524]
                                        )
                                      ]
                                      spids: [11524]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$arg")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\[">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\^">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\(">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\}">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\<">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\'">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                              (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                            {(DQ )}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      )
                                                    }
                                                  spids: [11584]
                                                )
                                              ]
                                              spids: [11584]
                                            )
                                          ]
                                          spids: [11552 11581 11592 -1]
                                        )
                                      ]
                                      spids: [11545 11549 11595]
                                    )
                                  ]
                                  spids: [11506 11513 11598 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$objext")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:objs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$objs") (" ") ($ VSub_Name "$arg"))}
                                          spids: [11612]
                                        )
                                      ]
                                      spids: [11612]
                                    )
                                  ]
                                  spids: [11602 11605 11620 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.lo)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$arg")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [11663]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [11666]
                                                    )
                                                  ]
                                                  spids: [11640 11661]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:pic_object)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [11673]
                                                )
                                              ]
                                              spids: [11673]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:non_pic_object)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [11676]
                                                )
                                              ]
                                              spids: [11676]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$arg")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (/) (Lit_Other "*")}
                                                    {(Lit_Other "*") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [(C {(.)} {($ VSub_Name "$arg")})]
                                                  spids: [11695 11704 11710 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [(C {(.)} {(./) ($ VSub_Name "$arg")})]
                                                  spids: [11713 11714 11721 -1]
                                                )
                                              ]
                                              spids: [11688 11692 11724]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-z)} 
                                                              {(DQ ($ VSub_Name "$pic_object"))}
                                                            )
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$non_pic_object")
                                                                    )
                                                                  }
                                                                )
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name "$pic_object")
                                                                        )
                                                                      } {(Lit_Other "=")} {(none)}
                                                                    )
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$non_pic_object"
                                                                          )
                                                                        )
                                                                      } {(Lit_Other "=")} {(none)}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              ]
                                                              op_id: Op_DPipe
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": cannot find name of object for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$arg") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [11791]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 11778]
                                                )
                                              ]
                                              spids: [-1 11800]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:xdir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$arg"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s%/[^/]*$%%">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [11809 11826]
                                                      )
                                                    }
                                                  spids: [11808]
                                                )
                                              ]
                                              spids: [11808]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$xdir"))} 
                                                          {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$arg"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:xdir)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [11849]
                                                        )
                                                      ]
                                                      spids: [11849]
                                                    )
                                                  ]
                                                  spids: [-1 11846]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:xdir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$xdir") (/))}
                                                      spids: [11855]
                                                    )
                                                  ]
                                                  spids: [11855]
                                                )
                                              ]
                                              spids: [11852 11862]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$pic_object"))} 
                                                          {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:pic_object)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$xdir") 
                                                                ($ VSub_Name "$pic_object")
                                                              )
                                                            }
                                                          spids: [11887]
                                                        )
                                                      ]
                                                      spids: [11887]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                                  {(Lit_Other "=")} {(dlfiles)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (AndOr
                                                                          children: [
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$build_libtool_libs"
                                                                                  )
                                                                                )
                                                                              } {(Lit_Other "=")} {(yes)}
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$dlopen_support"
                                                                                  )
                                                                                )
                                                                              } {(Lit_Other "=")} {(yes)}
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:dlfiles)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$dlfiles"
                                                                                ) (" ") ($ VSub_Name "$pic_object")
                                                                              )
                                                                            }
                                                                          spids: [11939]
                                                                        )
                                                                      ]
                                                                      spids: [11939]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:prev)
                                                                          op: Equal
                                                                          rhs: {(SQ )}
                                                                          spids: [11947]
                                                                        )
                                                                      ]
                                                                      spids: [11947]
                                                                    )
                                                                    (ControlFlow
                                                                      token: 
                                                                        <ControlFlow_Continue 
continue
                                                                        >
                                                                    )
                                                                  ]
                                                                  spids: [-1 11936]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:prev)
                                                                      op: Equal
                                                                      rhs: {(dlprefiles)}
                                                                      spids: [11960]
                                                                    )
                                                                  ]
                                                                  spids: [11960]
                                                                )
                                                              ]
                                                              spids: [11953 11964]
                                                            )
                                                          ]
                                                          spids: [-1 11908]
                                                        )
                                                      ]
                                                      spids: [-1 11967]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                                  {(Lit_Other "=")} {(dlprefiles)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:dlprefiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$dlprefiles") 
                                                                        (" ") ($ VSub_Name "$pic_object")
                                                                      )
                                                                    }
                                                                  spids: [11995]
                                                                )
                                                              ]
                                                              spids: [11995]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:prev)
                                                                  op: Equal
                                                                  rhs: {(SQ )}
                                                                  spids: [12003]
                                                                )
                                                              ]
                                                              spids: [12003]
                                                            )
                                                          ]
                                                          spids: [-1 11988]
                                                        )
                                                      ]
                                                      spids: [-1 12006]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libobjs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$libobjs") (" ") 
                                                                ($ VSub_Name "$pic_object")
                                                              )
                                                            }
                                                          spids: [12014]
                                                        )
                                                      ]
                                                      spids: [12014]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:arg)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$pic_object"))}
                                                          spids: [12022]
                                                        )
                                                      ]
                                                      spids: [12022]
                                                    )
                                                  ]
                                                  spids: [-1 11880]
                                                )
                                              ]
                                              spids: [-1 12028]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_Name "$non_pic_object"))} {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:non_pic_object)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$xdir") 
                                                                ($ VSub_Name "$non_pic_object")
                                                              )
                                                            }
                                                          spids: [12057]
                                                        )
                                                      ]
                                                      spids: [12057]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:non_pic_objects)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$non_pic_objects") 
                                                                (" ") ($ VSub_Name "$non_pic_object")
                                                              )
                                                            }
                                                          spids: [12069]
                                                        )
                                                      ]
                                                      spids: [12069]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} {(-z)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name "$pic_object")
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name "$pic_object")
                                                                        )
                                                                      } {(Lit_Other "=")} {(none)}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DPipe
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:arg)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name 
"$non_pic_object"
                                                                        )
                                                                      )
                                                                    }
                                                                  spids: [12104]
                                                                )
                                                              ]
                                                              spids: [12104]
                                                            )
                                                          ]
                                                          spids: [-1 12101]
                                                        )
                                                      ]
                                                      spids: [-1 12110]
                                                    )
                                                  ]
                                                  spids: [-1 12050]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:non_pic_object)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$pic_object"))}
                                                      spids: [12124]
                                                    )
                                                  ]
                                                  spids: [12124]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:non_pic_objects)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$non_pic_objects") (" ") 
                                                            ($ VSub_Name "$non_pic_object")
                                                          )
                                                        }
                                                      spids: [12130]
                                                    )
                                                  ]
                                                  spids: [12130]
                                                )
                                              ]
                                              spids: [12113 12138]
                                            )
                                          ]
                                          spids: [-1 11670]
                                        )
                                      ]
                                      else_action: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (SimpleCommand
                                                  words: [
                                                    {($ VSub_Name "$echo")}
                                                    {
                                                      (DQ ($ VSub_Name "$modename") (": ") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\`">
                                                        ) ($ VSub_Name "$arg") ("' is not a valid libtool object")
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 1
                                                      arg_word: {(2)}
                                                      spids: [12172]
                                                    )
                                                  ]
                                                )
                                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                              ]
                                              spids: [-1 12159]
                                            )
                                          ]
                                          else_action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:xdir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$arg"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s%/[^/]*$%%">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [12194 12211]
                                                      )
                                                    }
                                                  spids: [12193]
                                                )
                                              ]
                                              spids: [12193]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ (X) ($ VSub_Name "$xdir"))} 
                                                          {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$arg"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:xdir)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [12234]
                                                        )
                                                      ]
                                                      spids: [12234]
                                                    )
                                                  ]
                                                  spids: [-1 12231]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:xdir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$xdir") (/))}
                                                      spids: [12240]
                                                    )
                                                  ]
                                                  spids: [12240]
                                                )
                                              ]
                                              spids: [12237 12247]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:pic_object)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) (${ VSub_Name xdir) 
                                                                        (${ VSub_Name objdir) (/) (${ VSub_Name arg)
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ($ VSub_Name "$lo2o"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [12252 12278]
                                                      )
                                                    }
                                                  spids: [12251]
                                                )
                                              ]
                                              spids: [12251]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:non_pic_object)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) (${ VSub_Name xdir) 
                                                                        (${ VSub_Name arg)
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ($ VSub_Name "$lo2o"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [12282 12304]
                                                      )
                                                    }
                                                  spids: [12281]
                                                )
                                              ]
                                              spids: [12281]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:libobjs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$libobjs") (" ") 
                                                        ($ VSub_Name "$pic_object")
                                                      )
                                                    }
                                                  spids: [12307]
                                                )
                                              ]
                                              spids: [12307]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:non_pic_objects)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$non_pic_objects") (" ") 
                                                        ($ VSub_Name "$non_pic_object")
                                                      )
                                                    }
                                                  spids: [12315]
                                                )
                                              ]
                                              spids: [12315]
                                            )
                                          ]
                                          spids: [12181 12323]
                                        )
                                      ]
                                      spids: [12141 12326]
                                    )
                                  ]
                                  spids: [11624 11626 12329 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$libext")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$deplibs") (" ") ($ VSub_Name "$arg"))
                                            }
                                          spids: [12343]
                                        )
                                      ]
                                      spids: [12343]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:old_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$old_deplibs") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [12351]
                                        )
                                      ]
                                      spids: [12351]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [12333 12336 12362 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.la)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                  {(Lit_Other "=")} {(dlfiles)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlfiles)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$dlfiles") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [12396]
                                                )
                                              ]
                                              spids: [12396]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [12404]
                                                )
                                              ]
                                              spids: [12404]
                                            )
                                          ]
                                          spids: [-1 12389]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$prev"))} 
                                                  {(Lit_Other "=")} {(dlprefiles)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlprefiles)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$dlprefiles") (" ") 
                                                        ($ VSub_Name "$arg")
                                                      )
                                                    }
                                                  spids: [12427]
                                                )
                                              ]
                                              spids: [12427]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [12435]
                                                )
                                              ]
                                              spids: [12435]
                                            )
                                          ]
                                          spids: [12407 12420]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$deplibs") (" ") 
                                                    ($ VSub_Name "$arg")
                                                  )
                                                }
                                              spids: [12441]
                                            )
                                          ]
                                          spids: [12441]
                                        )
                                      ]
                                      spids: [12438 12449]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [12366 12368 12455 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$arg"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [12476 12493]
                                              )
                                            }
                                          spids: [12475]
                                        )
                                      ]
                                      spids: [12475]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$arg")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\[">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\^">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\(">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\}">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\<">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\'">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                              (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                            {(DQ )}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:arg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      )
                                                    }
                                                  spids: [12535]
                                                )
                                              ]
                                              spids: [12535]
                                            )
                                          ]
                                          spids: [12503 12532 12543 -1]
                                        )
                                      ]
                                      spids: [12496 12500 12546]
                                    )
                                  ]
                                  spids: [12463 12464 12549 -1]
                                )
                              ]
                              spids: [9211 9215 12552]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$arg"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [12577]
                                        )
                                      ]
                                      spids: [12577]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                ($ VSub_Name "$arg")
                                              )
                                            }
                                          spids: [12585]
                                        )
                                      ]
                                      spids: [12585]
                                    )
                                  ]
                                  spids: [-1 12574]
                                )
                              ]
                              spids: [-1 12593]
                            )
                          ]
                          spids: [7472 12596]
                        )
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prev"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") (": the ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\`">
                                    ) ($ VSub_Name "$prevarg") ("' option requires an argument")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [12627]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [12637]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 12614]
                        )
                      ]
                      spids: [-1 12646]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name "$export_dynamic"))} {(Lit_Other "=")} 
                                      {(yes)}
                                    )
                                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$export_dynamic_flag_spec"))})
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {(Lit_VarLike "arg=") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                ) ($ VSub_Name "$export_dynamic_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                              }
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$compile_command") (" ") ($ VSub_Name "$arg"))
                                    }
                                  spids: [12684]
                                )
                              ]
                              spids: [12684]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:finalize_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$finalize_command") (" ") ($ VSub_Name "$arg"))
                                    }
                                  spids: [12692]
                                )
                              ]
                              spids: [12692]
                            )
                          ]
                          spids: [-1 12673]
                        )
                      ]
                      spids: [-1 12700]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:oldlibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [12704]
                        )
                      ]
                      spids: [12704]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:outputname)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$output"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [12712 12729]
                              )
                            }
                          spids: [12711]
                        )
                      ]
                      spids: [12711]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libobjs_save)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$libobjs"))}
                          spids: [12732]
                        )
                      ]
                      spids: [12732]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath_var"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {(Lit_VarLike "shlib_search_path=") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\`">
                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (echo)
                              } 
                              {(EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\$">
                                ) (Lit_LBrace "{") ($ VSub_Name "$shlibpath_var") (Lit_RBrace "}") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                )
                              } {(EscapedLiteralPart token:<Lit_EscapedChar "\\|">)} 
                              {(EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (Xsed)} {(-e)} {(EscapedLiteralPart token:<Lit_EscapedChar "\\'">) (s/) (Lit_Other ":") (/)} 
                              {(/g) (EscapedLiteralPart token:<Lit_EscapedChar "\\'">) 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\`">
                                )
                              }
                            )
                          ]
                          spids: [-1 12750]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:shlib_search_path)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [12792]
                            )
                          ]
                          spids: [12792]
                        )
                      ]
                      spids: [12789 12795]
                    )
                    (C {(eval)} 
                      {(Lit_VarLike "sys_lib_search_path=") 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$sys_lib_search_path_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                      }
                    )
                    (C {(eval)} 
                      {(Lit_VarLike "sys_lib_dlsearch_path=") 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$sys_lib_dlsearch_path_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                      }
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:output_objdir)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$output"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%/[^/]*$%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [12816 12833]
                              )
                            }
                          spids: [12815]
                        )
                      ]
                      spids: [12815]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ (X) ($ VSub_Name "$output_objdir"))} {(Lit_Other "=")} 
                                  {(DQ (X) ($ VSub_Name "$output"))}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:output_objdir)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$objdir"))}
                                  spids: [12856]
                                )
                              ]
                              spids: [12856]
                            )
                          ]
                          spids: [-1 12853]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:output_objdir)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$objdir"))}
                              spids: [12865]
                            )
                          ]
                          spids: [12865]
                        )
                      ]
                      spids: [12862 12873]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$output_objdir"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$show")} 
                              {(DQ ($ VSub_Name "$mkdir") (" ") ($ VSub_Name "$output_objdir"))}
                            )
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$mkdir")} 
                              {($ VSub_Name "$output_objdir")}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:exit_status)
                                  op: Equal
                                  rhs: {($ VSub_QMark "$?")}
                                  spids: [12912]
                                )
                              ]
                              spids: [12912]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(DQ ($ VSub_Name "$exit_status"))} {(-ne)} {(0)})
                                            (C {(test)} {(KW_Bang "!")} {(-d)} 
                                              {(DQ ($ VSub_Name "$output_objdir"))}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(exit)} {($ VSub_Name "$exit_status")})]
                                  spids: [-1 12941]
                                )
                              ]
                              spids: [-1 12949]
                            )
                          ]
                          spids: [-1 12893]
                        )
                      ]
                      spids: [-1 12952]
                    )
                    (Case
                      to_match: {($ VSub_Name "$output")}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )}]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") (": you must specify an output file"))
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [12979]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [12989]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 12969 12998 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$libext")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:linkmode)
                                  op: Equal
                                  rhs: {(oldlib)}
                                  spids: [13006]
                                )
                              ]
                              spids: [13006]
                            )
                          ]
                          spids: [13001 13004 13009 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (.lo)}
                            {(Lit_Other "*") (.) ($ VSub_Name "$objext")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:linkmode)
                                  op: Equal
                                  rhs: {(obj)}
                                  spids: [13022]
                                )
                              ]
                              spids: [13022]
                            )
                          ]
                          spids: [13012 13020 13025 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.la)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:linkmode)
                                  op: Equal
                                  rhs: {(lib)}
                                  spids: [13032]
                                )
                              ]
                              spids: [13032]
                            )
                          ]
                          spids: [13028 13030 13035 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:linkmode)
                                  op: Equal
                                  rhs: {(prog)}
                                  spids: [13041]
                                )
                              ]
                              spids: [13041]
                            )
                          ]
                          spids: [13038 13039 13044 -1]
                        )
                      ]
                      spids: [12960 12964 13050]
                    )
                    (Case
                      to_match: {($ VSub_Name "$host")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (cygwin) (Lit_Other "*")}
                            {(Lit_Other "*") (mingw) (Lit_Other "*")}
                            {(Lit_Other "*") (pw32) (Lit_Other "*")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:duplicate_compiler_generated_deps)
                                  op: Equal
                                  rhs: {(yes)}
                                  spids: [13083]
                                )
                              ]
                              spids: [13083]
                            )
                          ]
                          spids: [13061 13076 13087 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:duplicate_compiler_generated_deps)
                                  op: Equal
                                  rhs: {($ VSub_Name "$duplicate_deps")}
                                  spids: [13094]
                                )
                              ]
                              spids: [13094]
                            )
                          ]
                          spids: [13090 13091 13098 -1]
                        )
                      ]
                      spids: [13054 13058 13101]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:specialdeplibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13104]
                        )
                      ]
                      spids: [13104]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13108]
                        )
                      ]
                      spids: [13108]
                    )
                    (ForEach
                      iter_name: deplib
                      iter_words: [{($ VSub_Name "$deplibs")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$duplicate_deps"))} 
                                          {(Lit_Other "=")} {(DQ (Xyes))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$libs") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$deplib") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:specialdeplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$specialdeplibs") (" ") 
                                                        ($ VSub_Name "$deplib")
                                                      )
                                                    }
                                                  spids: [13170]
                                                )
                                              ]
                                              spids: [13170]
                                            )
                                          ]
                                          spids: [13161 13168 13177 -1]
                                        )
                                      ]
                                      spids: [13151 13158 13180]
                                    )
                                  ]
                                  spids: [-1 13148]
                                )
                              ]
                              spids: [-1 13183]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:libs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$libs") (" ") ($ VSub_Name "$deplib"))}
                                  spids: [13186]
                                )
                              ]
                              spids: [13186]
                            )
                          ]
                          spids: [13128 13194]
                        )
                      spids: [13124 13126]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} {(lib)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:libs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$predeps") (" ") ($ VSub_Name "$libs") (" ") 
                                        ($ VSub_Name "$compiler_lib_search_path") (" ") ($ VSub_Name "$postdeps")
                                      )
                                    }
                                  spids: [13214]
                                )
                              ]
                              spids: [13214]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pre_post_deps)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13239]
                                )
                              ]
                              spids: [13239]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} 
                                          {
                                            (DQ (X) ($ VSub_Name "$duplicate_compiler_generated_deps"))
                                          } {(Lit_Other "=")} {(DQ (Xyes))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (ForEach
                                      iter_name: pre_post_dep
                                      iter_words: [
                                        {($ VSub_Name "$predeps")}
                                        {($ VSub_Name "$postdeps")}
                                      ]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$pre_post_deps") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$pre_post_dep") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:specialdeplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$specialdeplibs") 
                                                                (" ") ($ VSub_Name "$pre_post_deps")
                                                              )
                                                            }
                                                          spids: [13295]
                                                        )
                                                      ]
                                                      spids: [13295]
                                                    )
                                                  ]
                                                  spids: [13286 13293 13302 -1]
                                                )
                                              ]
                                              spids: [13276 13283 13305]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:pre_post_deps)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$pre_post_deps") (" ") 
                                                        ($ VSub_Name "$pre_post_dep")
                                                      )
                                                    }
                                                  spids: [13308]
                                                )
                                              ]
                                              spids: [13308]
                                            )
                                          ]
                                          spids: [13273 13316]
                                        )
                                      spids: [13267 13271]
                                    )
                                  ]
                                  spids: [-1 13259]
                                )
                              ]
                              spids: [-1 13319]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pre_post_deps)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13322]
                                )
                              ]
                              spids: [13322]
                            )
                          ]
                          spids: [-1 13211]
                        )
                      ]
                      spids: [-1 13325]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:deplibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13329]
                        )
                      ]
                      spids: [13329]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:newdependency_libs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13332]
                        )
                      ]
                      spids: [13332]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:newlib_search_path)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13335]
                        )
                      ]
                      spids: [13335]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:need_relink)
                          op: Equal
                          rhs: {(no)}
                          spids: [13338]
                        )
                      ]
                      spids: [13338]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:notinst_deplibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [13345]
                        )
                      ]
                      spids: [13345]
                    )
                    (Case
                      to_match: {($ VSub_Name "$linkmode")}
                      arms: [
                        (case_arm
                          pat_list: [{(lib)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:passes)
                                  op: Equal
                                  rhs: {(DQ ("conv link"))}
                                  spids: [13362]
                                )
                              ]
                              spids: [13362]
                            )
                            (ForEach
                              iter_name: file
                              iter_words: [{($ VSub_Name "$dlfiles")} {($ VSub_Name "$dlprefiles")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {($ VSub_Name "$file")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.la)}]
                                          spids: [13389 13391 13393 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": libraries can ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("-dlopen' only libtool libraries: ") ($ VSub_Name "$file")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [13410]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [13396 13397 13419 -1]
                                        )
                                      ]
                                      spids: [13382 13386 13422]
                                    )
                                  ]
                                  spids: [13379 13425]
                                )
                              spids: [13373 13377]
                            )
                          ]
                          spids: [13358 13359 13428 -1]
                        )
                        (case_arm
                          pat_list: [{(prog)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_deplibs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13435]
                                )
                              ]
                              spids: [13435]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:finalize_deplibs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13438]
                                )
                              ]
                              spids: [13438]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:alldeplibs)
                                  op: Equal
                                  rhs: {(no)}
                                  spids: [13441]
                                )
                              ]
                              spids: [13441]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:newdlfiles)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13445]
                                )
                              ]
                              spids: [13445]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:newdlprefiles)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [13448]
                                )
                              ]
                              spids: [13448]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:passes)
                                  op: Equal
                                  rhs: {(DQ ("conv scan dlopen dlpreopen link"))}
                                  spids: [13451]
                                )
                              ]
                              spids: [13451]
                            )
                          ]
                          spids: [13431 13432 13457 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:passes)
                                  op: Equal
                                  rhs: {(DQ (conv))}
                                  spids: [13463]
                                )
                              ]
                              spids: [13463]
                            )
                          ]
                          spids: [13460 13461 13469 -1]
                        )
                      ]
                      spids: [13351 13355 13472]
                    )
                    (ForEach
                      iter_name: pass
                      iter_words: [{($ VSub_Name "$passes")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} 
                                              {
                                                (DQ ($ VSub_Name "$linkmode") (",") 
                                                  ($ VSub_Name "$pass")
                                                )
                                              } {(Lit_Other "=")} {(DQ ("lib,link"))}
                                            )
                                            (C {(test)} 
                                              {
                                                (DQ ($ VSub_Name "$linkmode") (",") 
                                                  ($ VSub_Name "$pass")
                                                )
                                              } {(Lit_Other "=")} {(DQ ("prog,scan"))}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$deplibs"))}
                                          spids: [13524]
                                        )
                                      ]
                                      spids: [13524]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [13530]
                                        )
                                      ]
                                      spids: [13530]
                                    )
                                  ]
                                  spids: [-1 13521]
                                )
                              ]
                              spids: [-1 13533]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} 
                                          {(prog)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$pass")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(dlopen)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:libs)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$dlfiles"))}
                                                  spids: [13562]
                                                )
                                              ]
                                              spids: [13562]
                                            )
                                          ]
                                          spids: [13559 13560 13567 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(dlpreopen)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:libs)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$dlprefiles"))}
                                                  spids: [13573]
                                                )
                                              ]
                                              spids: [13573]
                                            )
                                          ]
                                          spids: [13570 13571 13578 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(link)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$deplibs") (" %DEPLIBS% ") 
                                                        ($ VSub_Name "$dependency_libs")
                                                      )
                                                    }
                                                  spids: [13584]
                                                )
                                              ]
                                              spids: [13584]
                                            )
                                          ]
                                          spids: [13581 13582 13591 -1]
                                        )
                                      ]
                                      spids: [13552 13556 13594]
                                    )
                                  ]
                                  spids: [-1 13549]
                                )
                              ]
                              spids: [-1 13597]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} {(Lit_Other "=")} 
                                          {(dlopen)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:save_deplibs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$deplibs"))}
                                          spids: [13620]
                                        )
                                      ]
                                      spids: [13620]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [13626]
                                        )
                                      ]
                                      spids: [13626]
                                    )
                                  ]
                                  spids: [-1 13613]
                                )
                              ]
                              spids: [-1 13629]
                            )
                            (ForEach
                              iter_name: deplib
                              iter_words: [{($ VSub_Name "$libs")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lib)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [13644]
                                        )
                                      ]
                                      spids: [13644]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:found)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [13647]
                                        )
                                      ]
                                      spids: [13647]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$deplib")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(-mt)}
                                            {(-mthreads)}
                                            {(-kthread)}
                                            {(-Kthread)}
                                            {(-pthread)}
                                            {(-pthreads)}
                                            {(--thread-safe)}
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {
                                                            (DQ ($ VSub_Name "$linkmode") (",") 
                                                              ($ VSub_Name "$pass")
                                                            )
                                                          } {(Lit_Other "=")} {(DQ ("prog,link"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:compile_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$compile_deplibs")
                                                              )
                                                            }
                                                          spids: [13694]
                                                        )
                                                      ]
                                                      spids: [13694]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$finalize_deplibs")
                                                              )
                                                            }
                                                          spids: [13702]
                                                        )
                                                      ]
                                                      spids: [13702]
                                                    )
                                                  ]
                                                  spids: [-1 13691]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:compiler_flags)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$compiler_flags") (" ") 
                                                            ($ VSub_Name "$deplib")
                                                          )
                                                        }
                                                      spids: [13713]
                                                    )
                                                  ]
                                                  spids: [13713]
                                                )
                                              ]
                                              spids: [13710 13721]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [13658 13671 13727 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-l) (Lit_Other "*")}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(KW_Bang "!") (Lit_Other "=")} {(lib)}
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(KW_Bang "!") (Lit_Other "=")} {(prog)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": warning: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-l' is ignored for archives/objects")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [13774]
                                                        )
                                                      ]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [-1 13762]
                                                )
                                              ]
                                              spids: [-1 13781]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:name)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) ($ VSub_Name "$deplib"))
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s/^-l//">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [13785 13802]
                                                      )
                                                    }
                                                  spids: [13784]
                                                )
                                              ]
                                              spids: [13784]
                                            )
                                            (ForEach
                                              iter_name: searchdir
                                              iter_words: [
                                                {($ VSub_Name "$newlib_search_path")}
                                                {($ VSub_Name "$lib_search_path")}
                                                {($ VSub_Name "$sys_lib_search_path")}
                                                {($ VSub_Name "$shlib_search_path")}
                                              ]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (ForEach
                                                      iter_name: search_ext
                                                      iter_words: [
                                                        {(.la)}
                                                        {($ VSub_Name "$std_shrext")}
                                                        {(.so)}
                                                        {(.a)}
                                                      ]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:lib)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$searchdir") 
                                                                        (/lib) (${ VSub_Name name) (${ VSub_Name search_ext)
                                                                      )
                                                                    }
                                                                  spids: [13845]
                                                                )
                                                              ]
                                                              spids: [13845]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-f)} 
                                                                          {(DQ ($ VSub_Name "$lib"))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$search_ext"
                                                                                      )
                                                                                    )
                                                                                  } {(Lit_Other "=")} {(DQ (.la))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: found
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(yes)}
                                                                                  spids: [13890]
                                                                                )
                                                                              ]
                                                                              spids: [13890]
                                                                            )
                                                                          ]
                                                                          spids: [-1 13887]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: found
                                                                                )
                                                                              op: Equal
                                                                              rhs: {(no)}
                                                                              spids: [13897]
                                                                            )
                                                                          ]
                                                                          spids: [13897]
                                                                        )
                                                                      ]
                                                                      spids: [13894 13901]
                                                                    )
                                                                    (ControlFlow
                                                                      token: 
                                                                        <ControlFlow_Break break>
                                                                      arg_word: {(2)}
                                                                    )
                                                                  ]
                                                                  spids: [-1 13869]
                                                                )
                                                              ]
                                                              spids: [-1 13909]
                                                            )
                                                          ]
                                                          spids: [13838 13912]
                                                        )
                                                      spids: [13828 13836]
                                                    )
                                                  ]
                                                  spids: [13820 13915]
                                                )
                                              spids: [13810 13818]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$found"))} 
                                                          {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ ($ VSub_Name "$linkmode") 
                                                                      (",") ($ VSub_Name "$pass")
                                                                    )
                                                                  } {(Lit_Other "=")} {(DQ ("prog,link"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:compile_deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$compile_deplibs")
                                                                      )
                                                                    }
                                                                  spids: [13959]
                                                                )
                                                              ]
                                                              spids: [13959]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: finalize_deplibs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$finalize_deplibs")
                                                                      )
                                                                    }
                                                                  spids: [13967]
                                                                )
                                                              ]
                                                              spids: [13967]
                                                            )
                                                          ]
                                                          spids: [-1 13956]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$deplibs")
                                                                  )
                                                                }
                                                              spids: [13978]
                                                            )
                                                          ]
                                                          spids: [13978]
                                                        )
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(Lit_Other "=")} {(lib)}
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: newdependency_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$newdependency_libs")
                                                                      )
                                                                    }
                                                                  spids: [13998]
                                                                )
                                                              ]
                                                              spids: [13998]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      ]
                                                      spids: [13975 14006]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [-1 13932]
                                                )
                                              ]
                                              else_action: [
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (Sentence
                                                          child: 
                                                            (C {(test)} 
                                                              {
                                                                (DQ (X) 
                                                                  ($ VSub_Name 
"$allow_libtool_libs_with_static_runtimes"
                                                                  )
                                                                )
                                                              } {(Lit_Other "=")} {(DQ (Xyes))}
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      action: [
                                                        (Case
                                                          to_match: 
                                                            {
                                                              (DQ (" ") ($ VSub_Name "$predeps") (" ") 
                                                                ($ VSub_Name "$postdeps") (" ")
                                                              )
                                                            }
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "*") 
                                                                  (DQ (" ") ($ VSub_Name "$deplib") 
                                                                    (" ")
                                                                  ) (Lit_Other "*")
                                                                }
                                                              ]
                                                              action: [
                                                                (If
                                                                  arms: [
                                                                    (if_arm
                                                                      cond: [
                                                                        (Sentence
                                                                          child: 
                                                                            (Subshell
                                                                              child: 
                                                                                (Pipeline
                                                                                  children: [
                                                                                    (C 
                                                                                      {
                                                                                        (${ 
VSub_Name SED
                                                                                        )
                                                                                      } {(-e)} {(SQ <2q>)} {($ VSub_Name "$lib")}
                                                                                    )
                                                                                    (C {(grep)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          (
"^# Generated by .*"
                                                                                          ) ($ VSub_Name "$PACKAGE")
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                  ]
                                                                                  negated: False
                                                                                )
                                                                              redirects: [
                                                                                (Redir
                                                                                  op_id: Redir_Great
                                                                                  fd: -1
                                                                                  arg_word: 
                                                                                    {(/dev/null)}
                                                                                  spids: [14095]
                                                                                )
                                                                                (Redir
                                                                                  op_id: 
Redir_GreatAnd
                                                                                  fd: 2
                                                                                  arg_word: {(1)}
                                                                                  spids: [14098]
                                                                                )
                                                                              ]
                                                                              spids: [14071 14093]
                                                                            )
                                                                          terminator: <Op_Semi ";">
                                                                        )
                                                                      ]
                                                                      action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: 
library_names
                                                                                )
                                                                              op: Equal
                                                                              rhs: {(SQ )}
                                                                              spids: [14105]
                                                                            )
                                                                          ]
                                                                          spids: [14105]
                                                                        )
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: old_library
                                                                                )
                                                                              op: Equal
                                                                              rhs: {(SQ )}
                                                                              spids: [14108]
                                                                            )
                                                                          ]
                                                                          spids: [14108]
                                                                        )
                                                                        (Case
                                                                          to_match: 
                                                                            {($ VSub_Name "$lib")}
                                                                          arms: [
                                                                            (case_arm
                                                                              pat_list: [
                                                                                {(Lit_Other "*") (/) 
                                                                                  (Lit_Other "*")
                                                                                }
                                                                                {(Lit_Other "*") 
                                                                                  (EscapedLiteralPart
                                                                                    token: 
                                                                                      <
Lit_EscapedChar "\\\\"
                                                                                      >
                                                                                  ) (Lit_Other "*")
                                                                                }
                                                                              ]
                                                                              action: [
                                                                                (C {(.)} 
                                                                                  {
                                                                                    ($ VSub_Name 
"$lib"
                                                                                    )
                                                                                  }
                                                                                )
                                                                              ]
                                                                              spids: [
14118
14127
14133
-1
                                                                              ]
                                                                            )
                                                                            (case_arm
                                                                              pat_list: [
                                                                                {(Lit_Other "*")}
                                                                              ]
                                                                              action: [
                                                                                (C {(.)} 
                                                                                  {(./) 
                                                                                    ($ VSub_Name 
"$lib"
                                                                                    )
                                                                                  }
                                                                                )
                                                                              ]
                                                                              spids: [
14136
14137
14144
-1
                                                                              ]
                                                                            )
                                                                          ]
                                                                          spids: [14111 14115 14147]
                                                                        )
                                                                        (ForEach
                                                                          iter_name: l
                                                                          iter_words: [
                                                                            {
                                                                              ($ VSub_Name 
"$old_library"
                                                                              )
                                                                            }
                                                                            {
                                                                              ($ VSub_Name 
"$library_names"
                                                                              )
                                                                            }
                                                                          ]
                                                                          do_arg_iter: False
                                                                          body: 
                                                                            (DoGroup
                                                                              children: [
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: ll
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (DQ 
                                                                                            ($ 
VSub_Name "$l"
                                                                                            )
                                                                                          )
                                                                                        }
                                                                                      spids: [14164]
                                                                                    )
                                                                                  ]
                                                                                  spids: [14164]
                                                                                )
                                                                              ]
                                                                              spids: [14161 14170]
                                                                            )
                                                                          spids: [14155 14159]
                                                                        )
                                                                        (If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (Sentence
                                                                                  child: 
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ (X) 
                                                                                          ($ 
VSub_Name "$ll"
                                                                                          )
                                                                                        )
                                                                                      } {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$old_library"))}
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ";">
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
found
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: {(no)}
                                                                                      spids: [14197]
                                                                                    )
                                                                                  ]
                                                                                  spids: [14197]
                                                                                )
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
ladir
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (CommandSubPart
                                                                                            command_list: 
                                                                                              (CommandList
                                                                                                children: [
                                                                                                  (Pipeline
                                                                                                    children: [
                                                                                                      (C 
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$echo"
                                                                                                          )
                                                                                                        } {(DQ (X) ($ VSub_Name "$lib"))}
                                                                                                      )
                                                                                                      (C 
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$Xsed"
                                                                                                          )
                                                                                                        } {(-e)} {(SQ <"s%/[^/]*$%%">)}
                                                                                                      )
                                                                                                    ]
                                                                                                    negated: 
False
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            left_token: 
                                                                                              <
Left_Backtick "`"
                                                                                              >
                                                                                            spids: [
14202
14219
                                                                                            ]
                                                                                          )
                                                                                        }
                                                                                      spids: [14201]
                                                                                    )
                                                                                  ]
                                                                                  spids: [14201]
                                                                                )
                                                                                (AndOr
                                                                                  children: [
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ (X) 
                                                                                          ($ 
VSub_Name "$ladir"
                                                                                          )
                                                                                        )
                                                                                      } {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$lib"))}
                                                                                    )
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
ladir
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ (.))
                                                                                            }
                                                                                          spids: [
14238
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [14238]
                                                                                    )
                                                                                  ]
                                                                                  op_id: Op_DAmp
                                                                                )
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: lib
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          ($ 
VSub_Name "$ladir"
                                                                                          ) (/) ($ VSub_Name "$old_library")
                                                                                        }
                                                                                      spids: [14244]
                                                                                    )
                                                                                  ]
                                                                                  spids: [14244]
                                                                                )
                                                                                (If
                                                                                  arms: [
                                                                                    (if_arm
                                                                                      cond: [
                                                                                        (Sentence
                                                                                          child: 
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(DQ ($ VSub_Name "$linkmode") (",") ($ VSub_Name "$pass"))} {(Lit_Other "=")} {(DQ ("prog,link"))}
                                                                                            )
                                                                                          terminator: 
                                                                                            <
Op_Semi ";"
                                                                                            >
                                                                                        )
                                                                                      ]
                                                                                      action: [
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
compile_deplibs
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$deplib"
                                                                                                    ) (" ") ($ VSub_Name "$compile_deplibs")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
14270
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
14270
                                                                                          ]
                                                                                        )
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
finalize_deplibs
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$deplib"
                                                                                                    ) (" ") ($ VSub_Name "$finalize_deplibs")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
14278
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
14278
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
14267
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  else_action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
deplibs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$deplib"
                                                                                                ) (" ") ($ VSub_Name "$deplibs")
                                                                                              )
                                                                                            }
                                                                                          spids: [
14289
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [14289]
                                                                                    )
                                                                                    (AndOr
                                                                                      children: [
                                                                                        (C {(test)} 
                                                                                          {
                                                                                            (DQ 
                                                                                              ($ 
VSub_Name "$linkmode"
                                                                                              )
                                                                                            )
                                                                                          } {(Lit_Other "=")} {(lib)}
                                                                                        )
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
newdependency_libs
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$deplib"
                                                                                                    ) (" ") ($ VSub_Name "$newdependency_libs")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
14309
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
14309
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      op_id: Op_DAmp
                                                                                    )
                                                                                  ]
                                                                                  spids: [14286 14317]
                                                                                )
                                                                                (ControlFlow
                                                                                  token: 
                                                                                    <
ControlFlow_Continue continue
                                                                                    >
                                                                                )
                                                                              ]
                                                                              spids: [-1 14191]
                                                                            )
                                                                          ]
                                                                          spids: [-1 14323]
                                                                        )
                                                                      ]
                                                                      spids: [-1 14102]
                                                                    )
                                                                  ]
                                                                  spids: [-1 14326]
                                                                )
                                                              ]
                                                              spids: [14059 14066 14329 -1]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Other "*")}]
                                                              spids: [14332 14333 14335 -1]
                                                            )
                                                          ]
                                                          spids: [14046 14056 14338]
                                                        )
                                                      ]
                                                      spids: [-1 14043]
                                                    )
                                                  ]
                                                  spids: [-1 14341]
                                                )
                                              ]
                                              spids: [14012 14344]
                                            )
                                          ]
                                          spids: [13730 13732 14347 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-L) (Lit_Other "*")}]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$linkmode")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(lib)}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$deplibs")
                                                              )
                                                            }
                                                          spids: [14369]
                                                        )
                                                      ]
                                                      spids: [14369]
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                          {(Lit_Other "=")} {(conv)}
                                                        )
                                                        (ControlFlow
                                                          token: <ControlFlow_Continue continue>
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdependency_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$newdependency_libs")
                                                              )
                                                            }
                                                          spids: [14392]
                                                        )
                                                      ]
                                                      spids: [14392]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newlib_search_path)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$newlib_search_path") 
                                                                (" ")
                                                              ) 
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} {(SQ <"s/^-L//">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [14405 14422]
                                                              )
                                                            }
                                                          spids: [14400]
                                                        )
                                                      ]
                                                      spids: [14400]
                                                    )
                                                  ]
                                                  spids: [14365 14366 14425 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(prog)}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                                  {(Lit_Other "=")} {(conv)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [14448]
                                                                )
                                                              ]
                                                              spids: [14448]
                                                            )
                                                            (ControlFlow
                                                              token: <ControlFlow_Continue continue>
                                                            )
                                                          ]
                                                          spids: [-1 14445]
                                                        )
                                                      ]
                                                      spids: [-1 14459]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                                  {(Lit_Other "=")} {(scan)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [14478]
                                                                )
                                                              ]
                                                              spids: [14478]
                                                            )
                                                          ]
                                                          spids: [-1 14475]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:compile_deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$compile_deplibs")
                                                                  )
                                                                }
                                                              spids: [14489]
                                                            )
                                                          ]
                                                          spids: [14489]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:finalize_deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$finalize_deplibs")
                                                                  )
                                                                }
                                                              spids: [14497]
                                                            )
                                                          ]
                                                          spids: [14497]
                                                        )
                                                      ]
                                                      spids: [14486 14505]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newlib_search_path)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$newlib_search_path") 
                                                                (" ")
                                                              ) 
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} {(SQ <"s/^-L//">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [14513 14530]
                                                              )
                                                            }
                                                          spids: [14508]
                                                        )
                                                      ]
                                                      spids: [14508]
                                                    )
                                                  ]
                                                  spids: [14428 14429 14533 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": warning: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-L' is ignored for archives/objects")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [14549]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [14536 14537 14553 -1]
                                                )
                                              ]
                                              spids: [14358 14362 14556]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [14353 14355 14565 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(-R) (Lit_Other "*")}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                          {(Lit_Other "=")} {(link)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dir)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} {(SQ <"s/^-R//">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [14593 14610]
                                                              )
                                                            }
                                                          spids: [14592]
                                                        )
                                                      ]
                                                      spids: [14592]
                                                    )
                                                    (Case
                                                      to_match: {(DQ ($ VSub_Name "$xrpath") (" "))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$dir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [14627 14634 14636 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:xrpath)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$xrpath") 
                                                                        (" ") ($ VSub_Name "$dir")
                                                                      )
                                                                    }
                                                                  spids: [14642]
                                                                )
                                                              ]
                                                              spids: [14642]
                                                            )
                                                          ]
                                                          spids: [14639 14640 14649 -1]
                                                        )
                                                      ]
                                                      spids: [14617 14624 14652]
                                                    )
                                                  ]
                                                  spids: [-1 14589]
                                                )
                                              ]
                                              spids: [-1 14655]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$deplib") (" ") 
                                                        ($ VSub_Name "$deplibs")
                                                      )
                                                    }
                                                  spids: [14658]
                                                )
                                              ]
                                              spids: [14658]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [14571 14573 14669 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.la)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lib)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$deplib"))}
                                                  spids: [14676]
                                                )
                                              ]
                                              spids: [14676]
                                            )
                                          ]
                                          spids: [14672 14674 14681 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$libext")}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                          {(Lit_Other "=")} {(conv)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$deplibs")
                                                              )
                                                            }
                                                          spids: [14706]
                                                        )
                                                      ]
                                                      spids: [14706]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [-1 14703]
                                                )
                                              ]
                                              spids: [-1 14717]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$linkmode")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(lib)}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:valid_a_lib)
                                                          op: Equal
                                                          rhs: {(no)}
                                                          spids: [14731]
                                                        )
                                                      ]
                                                      spids: [14731]
                                                    )
                                                    (Case
                                                      to_match: 
                                                        {($ VSub_Name "$deplibs_check_method")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(match_pattern) (Lit_Other "*")}]
                                                          action: [
                                                            (C {(set)} {(dummy)} 
                                                              {
                                                                ($ VSub_Name "$deplibs_check_method")
                                                              }
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: match_pattern_regex
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (C {(expr)} 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$deplibs_check_method"
                                                                                    )
                                                                                  )
                                                                                } {(Lit_Other ":")} 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Number 
"$2"
                                                                                    ) (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\(">) (".*") 
                                                                                    (EscapedLiteralPart
                                                                                      token: 
                                                                                        <
Lit_EscapedChar "\\)"
                                                                                        >
                                                                                    )
                                                                                  )
                                                                                }
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [14755 14771]
                                                                      )
                                                                    }
                                                                  spids: [14754]
                                                                )
                                                              ]
                                                              spids: [14754]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (Pipeline
                                                                          children: [
                                                                            (SimpleCommand
                                                                              words: [
                                                                                {(eval)}
                                                                                {
                                                                                  ($ VSub_Name 
"$echo"
                                                                                  )
                                                                                }
                                                                                {
                                                                                  (EscapedLiteralPart
                                                                                    token: 
                                                                                      <
Lit_EscapedChar "\\\""
                                                                                      >
                                                                                  ) ($ VSub_Name "$deplib") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (Redir
                                                                                  op_id: Redir_Great
                                                                                  fd: 2
                                                                                  arg_word: 
                                                                                    {(/dev/null)}
                                                                                  spids: [14784]
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {($ VSub_Name "$SED")} 
                                                                              {(10q)}
                                                                            )
                                                                            (SimpleCommand
                                                                              words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$EGREP"
                                                                                  )
                                                                                }
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$match_pattern_regex"
                                                                                    )
                                                                                  )
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (Redir
                                                                                  op_id: Redir_Great
                                                                                  fd: -1
                                                                                  arg_word: 
                                                                                    {(/dev/null)}
                                                                                  spids: [14805]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                          negated: False
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: valid_a_lib
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(yes)}
                                                                          spids: [14813]
                                                                        )
                                                                      ]
                                                                      spids: [14813]
                                                                    )
                                                                  ]
                                                                  spids: [-1 14810]
                                                                )
                                                              ]
                                                              spids: [-1 14817]
                                                            )
                                                          ]
                                                          spids: [14742 14744 14820 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(pass_all)}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:valid_a_lib)
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                  spids: [14827]
                                                                )
                                                              ]
                                                              spids: [14827]
                                                            )
                                                          ]
                                                          spids: [14823 14824 14831 -1]
                                                        )
                                                      ]
                                                      spids: [14735 14739 14834]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$valid_a_lib"))} {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")})
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** Warning: Trying to link with static lib archive "
                                                                  ) ($ VSub_Name "$deplib") (.)
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** I have the capability to make that library automatically link in when"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** you link to this library.  But I can only do this if you have a"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** shared version of the library, which you do not appear to have"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** because the file extensions ."
                                                                  ) ($ VSub_Name "$libext") (" of this argument makes me believe")
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** that it is just a static archive that I should not used here."
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 14851]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$echo")})
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** Warning: Linking the shared library "
                                                              ) ($ VSub_Name "$output") (" against the")
                                                            )
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ ("*** static library ") 
                                                              ($ VSub_Name "$deplib") (" is not portable!")
                                                            )
                                                          }
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$deplibs")
                                                                  )
                                                                }
                                                              spids: [14927]
                                                            )
                                                          ]
                                                          spids: [14927]
                                                        )
                                                      ]
                                                      spids: [14903 14935]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [14727 14728 14941 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(prog)}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                                  {(KW_Bang "!") (Lit_Other "=")} {(link)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [14965]
                                                                )
                                                              ]
                                                              spids: [14965]
                                                            )
                                                          ]
                                                          spids: [-1 14962]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:compile_deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$compile_deplibs")
                                                                  )
                                                                }
                                                              spids: [14976]
                                                            )
                                                          ]
                                                          spids: [14976]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:finalize_deplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name "$finalize_deplibs")
                                                                  )
                                                                }
                                                              spids: [14984]
                                                            )
                                                          ]
                                                          spids: [14984]
                                                        )
                                                      ]
                                                      spids: [14973 14992]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [14944 14945 14998 -1]
                                                )
                                              ]
                                              spids: [14720 14724 15001]
                                            )
                                          ]
                                          spids: [14684 14687 15007 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (.lo)}
                                            {(Lit_Other "*") (.) ($ VSub_Name "$objext")}
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                          {(Lit_Other "=")} {(conv)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$deplibs")
                                                              )
                                                            }
                                                          spids: [15040]
                                                        )
                                                      ]
                                                      spids: [15040]
                                                    )
                                                  ]
                                                  spids: [-1 15037]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                          {(Lit_Other "=")} {(prog)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {(DQ ($ VSub_Name "$pass"))} {(Lit_Other "=")} {(dlpreopen)}
                                                                    )
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$dlopen_support"
                                                                              )
                                                                            )
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                        )
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$build_libtool_libs"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                      ]
                                                                      op_id: Op_DPipe
                                                                    )
                                                                  ]
                                                                  op_id: Op_DPipe
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:newdlprefiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$newdlprefiles") (" ") ($ VSub_Name "$deplib")
                                                                      )
                                                                    }
                                                                  spids: [15113]
                                                                )
                                                              ]
                                                              spids: [15113]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:compile_deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$compile_deplibs")
                                                                      )
                                                                    }
                                                                  spids: [15121]
                                                                )
                                                              ]
                                                              spids: [15121]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: finalize_deplibs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$finalize_deplibs")
                                                                      )
                                                                    }
                                                                  spids: [15129]
                                                                )
                                                              ]
                                                              spids: [15129]
                                                            )
                                                          ]
                                                          spids: [-1 15102]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdlfiles)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$newdlfiles") 
                                                                    (" ") ($ VSub_Name "$deplib")
                                                                  )
                                                                }
                                                              spids: [15140]
                                                            )
                                                          ]
                                                          spids: [15140]
                                                        )
                                                      ]
                                                      spids: [15137 15148]
                                                    )
                                                  ]
                                                  spids: [15048 15061]
                                                )
                                              ]
                                              spids: [-1 15151]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [15013 15021 15157 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "%") (DEPLIBS) (Lit_Other "%")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:alldeplibs)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [15166]
                                                )
                                              ]
                                              spids: [15166]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [15160 15163 15173 -1]
                                        )
                                      ]
                                      spids: [13651 13655 15176]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$found"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                    (C {(test)} {(-f)} {(DQ ($ VSub_Name "$lib"))})
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 15205]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") 
                                                (": cannot find the library ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("' or unhandled argument ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$deplib") ("'")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [15226]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [15210 15235]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$lib")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [15268]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [15271]
                                                    )
                                                  ]
                                                  spids: [15245 15266]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 15275]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$lib") ("' is not a valid libtool archive")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [15293]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [15280 15302]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:ladir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$lib"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%/[^/]*$%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [15307 15324]
                                              )
                                            }
                                          spids: [15306]
                                        )
                                      ]
                                      spids: [15306]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$ladir"))} {(Lit_Other "=")} 
                                          {(DQ (X) ($ VSub_Name "$lib"))}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:ladir)
                                              op: Equal
                                              rhs: {(DQ (.))}
                                              spids: [15343]
                                            )
                                          ]
                                          spids: [15343]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dlname)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15350]
                                        )
                                      ]
                                      spids: [15350]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dlopen)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15353]
                                        )
                                      ]
                                      spids: [15353]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dlpreopen)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15356]
                                        )
                                      ]
                                      spids: [15356]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libdir)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15359]
                                        )
                                      ]
                                      spids: [15359]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:library_names)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15362]
                                        )
                                      ]
                                      spids: [15362]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:old_library)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15365]
                                        )
                                      ]
                                      spids: [15365]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:installed)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [15376]
                                        )
                                      ]
                                      spids: [15376]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:shouldnotlink)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [15380]
                                        )
                                      ]
                                      spids: [15380]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:avoidtemprpath)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15384]
                                        )
                                      ]
                                      spids: [15384]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$lib")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (/) (Lit_Other "*")}
                                            {(Lit_Other "*") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          action: [(C {(.)} {($ VSub_Name "$lib")})]
                                          spids: [15400 15409 15415 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [(C {(.)} {(./) ($ VSub_Name "$lib")})]
                                          spids: [15418 15419 15426 -1]
                                        )
                                      ]
                                      spids: [15393 15397 15429]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} 
                                                      {
                                                        (DQ ($ VSub_Name "$linkmode") (",") 
                                                          ($ VSub_Name "$pass")
                                                        )
                                                      } {(Lit_Other "=")} {(DQ ("lib,link"))}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} 
                                                          {
                                                            (DQ ($ VSub_Name "$linkmode") (",") 
                                                              ($ VSub_Name "$pass")
                                                            )
                                                          } {(Lit_Other "=")} {(DQ ("prog,scan"))}
                                                        )
                                                        (BraceGroup
                                                          children: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ ($ VSub_Name "$linkmode"))
                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(prog)}
                                                                    )
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ ($ VSub_Name "$linkmode"))
                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(lib)}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          spids: [15469]
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dlopen"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dlfiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$dlfiles") (" ") 
                                                            ($ VSub_Name "$dlopen")
                                                          )
                                                        }
                                                      spids: [15512]
                                                    )
                                                  ]
                                                  spids: [15512]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dlpreopen"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dlprefiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$dlprefiles") (" ") 
                                                            ($ VSub_Name "$dlpreopen")
                                                          )
                                                        }
                                                      spids: [15530]
                                                    )
                                                  ]
                                                  spids: [15530]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          spids: [-1 15499]
                                        )
                                      ]
                                      spids: [-1 15538]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                  {(Lit_Other "=")} {(conv)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$lib") (" ") 
                                                        ($ VSub_Name "$deplibs")
                                                      )
                                                    }
                                                  spids: [15562]
                                                )
                                              ]
                                              spids: [15562]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$libdir"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {(DQ ($ VSub_Name "$old_library"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (SimpleCommand
                                                              words: [
                                                                {($ VSub_Name "$echo")}
                                                                {
                                                                  (DQ ($ VSub_Name "$modename") 
                                                                    (
": cannot find name of link library for "
                                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("'")
                                                                  )
                                                                }
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_GreatAnd
                                                                  fd: 1
                                                                  arg_word: {(2)}
                                                                  spids: [15608]
                                                                )
                                                              ]
                                                            )
                                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                          ]
                                                          spids: [-1 15595]
                                                        )
                                                      ]
                                                      spids: [-1 15617]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:convenience)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$convenience") (" ") 
                                                                ($ VSub_Name "$ladir") (/) ($ VSub_Name "$objdir") (/) ($ VSub_Name "$old_library")
                                                              )
                                                            }
                                                          spids: [15624]
                                                        )
                                                      ]
                                                      spids: [15624]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:old_convenience)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$old_convenience") 
                                                                (" ") ($ VSub_Name "$ladir") (/) ($ VSub_Name "$objdir") (/) ($ VSub_Name "$old_library")
                                                              )
                                                            }
                                                          spids: [15636]
                                                        )
                                                      ]
                                                      spids: [15636]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tmp_libs)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [15648]
                                                        )
                                                      ]
                                                      spids: [15648]
                                                    )
                                                    (ForEach
                                                      iter_name: deplib
                                                      iter_words: [{($ VSub_Name "$dependency_libs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [15663]
                                                                )
                                                              ]
                                                              spids: [15663]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ (X) 
                                                                              ($ VSub_Name 
"$duplicate_deps"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$tmp_libs") (" ")
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") 
                                                                              (DQ (" ") 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                ) (" ")
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
specialdeplibs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$specialdeplibs"
                                                                                        ) (" ") ($ VSub_Name "$deplib")
                                                                                      )
                                                                                    }
                                                                                  spids: [15710]
                                                                                )
                                                                              ]
                                                                              spids: [15710]
                                                                            )
                                                                          ]
                                                                          spids: [15701 15708 15717 -1]
                                                                        )
                                                                      ]
                                                                      spids: [15691 15698 15720]
                                                                    )
                                                                  ]
                                                                  spids: [-1 15688]
                                                                )
                                                              ]
                                                              spids: [-1 15723]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:tmp_libs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$tmp_libs") 
                                                                        (" ") ($ VSub_Name "$deplib")
                                                                      )
                                                                    }
                                                                  spids: [15726]
                                                                )
                                                              ]
                                                              spids: [15726]
                                                            )
                                                          ]
                                                          spids: [15660 15734]
                                                        )
                                                      spids: [15656 15658]
                                                    )
                                                  ]
                                                  spids: [-1 15581]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(KW_Bang "!") (Lit_Other "=")} {(prog)}
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(KW_Bang "!") (Lit_Other "=")} {(lib)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") (": ") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\`">
                                                            ) ($ VSub_Name "$lib") ("' is not a convenience library")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [15777]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [15737 15764]
                                                )
                                              ]
                                              spids: [-1 15786]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [-1 15555]
                                        )
                                      ]
                                      spids: [-1 15792]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:linklib)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [15804]
                                        )
                                      ]
                                      spids: [15804]
                                    )
                                    (ForEach
                                      iter_name: l
                                      iter_words: [
                                        {($ VSub_Name "$old_library")}
                                        {($ VSub_Name "$library_names")}
                                      ]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linklib)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$l"))}
                                                  spids: [15821]
                                                )
                                              ]
                                              spids: [15821]
                                            )
                                          ]
                                          spids: [15818 15827]
                                        )
                                      spids: [15812 15816]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$linklib"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": cannot find name of link library for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [15854]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [-1 15841]
                                        )
                                      ]
                                      spids: [-1 15863]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                  {(Lit_Other "=")} {(dlopen)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$libdir"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": cannot -dlopen a convenience library: "
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [15911]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 15898]
                                                )
                                              ]
                                              spids: [-1 15920]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-z)} 
                                                              {(DQ ($ VSub_Name "$dlname"))}
                                                            )
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$dlopen_support")
                                                                    )
                                                                  } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                )
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$build_libtool_libs"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(no)}
                                                                )
                                                              ]
                                                              op_id: Op_DPipe
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dlprefiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dlprefiles") (" ") 
                                                                ($ VSub_Name "$lib") (" ") ($ VSub_Name "$dependency_libs")
                                                              )
                                                            }
                                                          spids: [15980]
                                                        )
                                                      ]
                                                      spids: [15980]
                                                    )
                                                  ]
                                                  spids: [-1 15961]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:newdlfiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$newdlfiles") (" ") 
                                                            ($ VSub_Name "$lib")
                                                          )
                                                        }
                                                      spids: [15993]
                                                    )
                                                  ]
                                                  spids: [15993]
                                                )
                                              ]
                                              spids: [15990 16001]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [-1 15884]
                                        )
                                      ]
                                      spids: [-1 16007]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$ladir")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") 
                                              (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:abs_ladir)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$ladir"))}
                                                  spids: [16044]
                                                )
                                              ]
                                              spids: [16044]
                                            )
                                          ]
                                          spids: [16025 16042 16049 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:abs_ladir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (AndOr
                                                                children: [
                                                                  (C {(cd)} 
                                                                    {(DQ ($ VSub_Name "$ladir"))}
                                                                  )
                                                                  (C {(pwd)})
                                                                ]
                                                                op_id: Op_DAmp
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [16057 16067]
                                                      )
                                                    }
                                                  spids: [16056]
                                                )
                                              ]
                                              spids: [16056]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_Name "$abs_ladir"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": warning: cannot determine absolute directory name of "
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$ladir") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [16094]
                                                        )
                                                      ]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": passing it literally to the linker, although it might fail"
                                                            )
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [16105]
                                                        )
                                                      ]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:abs_ladir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$ladir"))}
                                                          spids: [16109]
                                                        )
                                                      ]
                                                      spids: [16109]
                                                    )
                                                  ]
                                                  spids: [-1 16081]
                                                )
                                              ]
                                              spids: [-1 16115]
                                            )
                                          ]
                                          spids: [16052 16053 16118 -1]
                                        )
                                      ]
                                      spids: [16018 16022 16121]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:laname)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$lib"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%^.*/%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [16125 16142]
                                              )
                                            }
                                          spids: [16124]
                                        )
                                      ]
                                      spids: [16124]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$installed"))} 
                                                  {(Lit_Other "=")} {(Xyes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(KW_Bang "!")} {(-f)} 
                                                              {
                                                                (DQ ($ VSub_Name "$libdir") (/) 
                                                                  ($ VSub_Name "$linklib")
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(-f)} 
                                                              {
                                                                (DQ ($ VSub_Name "$abs_ladir") (/) 
                                                                  ($ VSub_Name "$linklib")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": warning: library ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("' was moved.")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [16207]
                                                        )
                                                      ]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$ladir"))}
                                                          spids: [16211]
                                                        )
                                                      ]
                                                      spids: [16211]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:absdir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$abs_ladir"))}
                                                          spids: [16217]
                                                        )
                                                      ]
                                                      spids: [16217]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libdir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$abs_ladir"))}
                                                          spids: [16223]
                                                        )
                                                      ]
                                                      spids: [16223]
                                                    )
                                                  ]
                                                  spids: [-1 16194]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$libdir"))}
                                                      spids: [16232]
                                                    )
                                                  ]
                                                  spids: [16232]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:absdir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$libdir"))}
                                                      spids: [16238]
                                                    )
                                                  ]
                                                  spids: [16238]
                                                )
                                              ]
                                              spids: [16229 16244]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} 
                                                  {(DQ (X) ($ VSub_Name "$hardcode_automatic"))} {(Lit_Other "=")} {(Xyes)}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:avoidtemprpath)
                                                      op: Equal
                                                      rhs: {(yes)}
                                                      spids: [16260]
                                                    )
                                                  ]
                                                  spids: [16260]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          spids: [-1 16164]
                                        )
                                      ]
                                      else_action: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(KW_Bang "!")} {(-f)} 
                                                          {
                                                            (DQ ($ VSub_Name "$ladir") (/) 
                                                              ($ VSub_Name "$objdir") (/) ($ VSub_Name "$linklib")
                                                            )
                                                          }
                                                        )
                                                        (C {(test)} {(-f)} 
                                                          {
                                                            (DQ ($ VSub_Name "$abs_ladir") (/) 
                                                              ($ VSub_Name "$linklib")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$ladir"))}
                                                      spids: [16299]
                                                    )
                                                  ]
                                                  spids: [16299]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:absdir)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$abs_ladir"))}
                                                      spids: [16305]
                                                    )
                                                  ]
                                                  spids: [16305]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:notinst_path)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$notinst_path") (" ") 
                                                            ($ VSub_Name "$abs_ladir")
                                                          )
                                                        }
                                                      spids: [16315]
                                                    )
                                                  ]
                                                  spids: [16315]
                                                )
                                              ]
                                              spids: [-1 16296]
                                            )
                                          ]
                                          else_action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$ladir") (/) 
                                                        ($ VSub_Name "$objdir")
                                                      )
                                                    }
                                                  spids: [16326]
                                                )
                                              ]
                                              spids: [16326]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:absdir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$abs_ladir") (/) 
                                                        ($ VSub_Name "$objdir")
                                                      )
                                                    }
                                                  spids: [16334]
                                                )
                                              ]
                                              spids: [16334]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:notinst_path)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$notinst_path") (" ") 
                                                        ($ VSub_Name "$abs_ladir")
                                                      )
                                                    }
                                                  spids: [16346]
                                                )
                                              ]
                                              spids: [16346]
                                            )
                                          ]
                                          spids: [16323 16354]
                                        )
                                      ]
                                      spids: [16264 16357]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:name)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$laname"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/\\.la$//">)} {(-e)} {(SQ <"s/^lib//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [16364 16387]
                                              )
                                            }
                                          spids: [16363]
                                        )
                                      ]
                                      spids: [16363]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                  {(Lit_Other "=")} {(dlpreopen)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$libdir"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (
": cannot -dlpreopen a convenience library: "
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [16435]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 16422]
                                                )
                                              ]
                                              spids: [-1 16444]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$old_library"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdlprefiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$newdlprefiles") (" ") 
                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$old_library")
                                                              )
                                                            }
                                                          spids: [16469]
                                                        )
                                                      ]
                                                      spids: [16469]
                                                    )
                                                  ]
                                                  spids: [-1 16466]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dlname"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdlprefiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$newdlprefiles") (" ") 
                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$dlname")
                                                              )
                                                            }
                                                          spids: [16497]
                                                        )
                                                      ]
                                                      spids: [16497]
                                                    )
                                                  ]
                                                  spids: [16483 16494]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:newdlprefiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$newdlprefiles") (" ") 
                                                            ($ VSub_Name "$dir") (/) ($ VSub_Name "$linklib")
                                                          )
                                                        }
                                                      spids: [16510]
                                                    )
                                                  ]
                                                  spids: [16510]
                                                )
                                              ]
                                              spids: [16507 16520]
                                            )
                                          ]
                                          spids: [-1 16408]
                                        )
                                      ]
                                      spids: [-1 16523]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$libdir"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                          {(Lit_Other "=")} {(lib)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dir") (/) 
                                                                ($ VSub_Name "$old_library") (" ") ($ VSub_Name "$deplibs")
                                                              )
                                                            }
                                                          spids: [16564]
                                                        )
                                                      ]
                                                      spids: [16564]
                                                    )
                                                  ]
                                                  spids: [-1 16561]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {
                                                            (DQ ($ VSub_Name "$linkmode") (",") 
                                                              ($ VSub_Name "$pass")
                                                            )
                                                          } {(Lit_Other "=")} {(DQ ("prog,link"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:compile_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dir") (/) 
                                                                ($ VSub_Name "$old_library") (" ") ($ VSub_Name "$compile_deplibs")
                                                              )
                                                            }
                                                          spids: [16594]
                                                        )
                                                      ]
                                                      spids: [16594]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dir") (/) 
                                                                ($ VSub_Name "$old_library") (" ") ($ VSub_Name "$finalize_deplibs")
                                                              )
                                                            }
                                                          spids: [16604]
                                                        )
                                                      ]
                                                      spids: [16604]
                                                    )
                                                  ]
                                                  spids: [16574 16591]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$lib") (" ") 
                                                            ($ VSub_Name "$deplibs")
                                                          )
                                                        }
                                                      spids: [16617]
                                                    )
                                                  ]
                                                  spids: [16617]
                                                )
                                              ]
                                              spids: [16614 16628]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [-1 16541]
                                        )
                                      ]
                                      spids: [-1 16634]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                      {(Lit_Other "=")} {(prog)}
                                                    )
                                                    (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                      {(KW_Bang "!") (Lit_Other "=")} {(link)}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newlib_search_path)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$newlib_search_path") (" ") 
                                                        ($ VSub_Name "$ladir")
                                                      )
                                                    }
                                                  spids: [16668]
                                                )
                                              ]
                                              spids: [16668]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$lib") (" ") 
                                                        ($ VSub_Name "$deplibs")
                                                      )
                                                    }
                                                  spids: [16676]
                                                )
                                              ]
                                              spids: [16676]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linkalldeplibs)
                                                  op: Equal
                                                  rhs: {(no)}
                                                  spids: [16685]
                                                )
                                              ]
                                              spids: [16685]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {
                                                                (DQ ($ VSub_Name "$link_all_deplibs"))
                                                              } {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                                            )
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$library_names")
                                                                    )
                                                                  }
                                                                )
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$build_libtool_libs"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(no)}
                                                                )
                                                              ]
                                                              op_id: Op_DPipe
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:linkalldeplibs)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                          spids: [16729]
                                                        )
                                                      ]
                                                      spids: [16729]
                                                    )
                                                  ]
                                                  spids: [-1 16726]
                                                )
                                              ]
                                              spids: [-1 16733]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tmp_libs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [16737]
                                                )
                                              ]
                                              spids: [16737]
                                            )
                                            (ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_Name "$dependency_libs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Case
                                                      to_match: {($ VSub_Name "$deplib")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-L) (Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: newlib_search_path
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name 
"$newlib_search_path"
                                                                        ) (" ")
                                                                      ) 
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$deplib"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} {(SQ <"s/^-L//">)}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [16768 16785]
                                                                      )
                                                                    }
                                                                  spids: [16763]
                                                                )
                                                              ]
                                                              spids: [16763]
                                                            )
                                                          ]
                                                          spids: [16759 16761 16786 -1]
                                                        )
                                                      ]
                                                      spids: [16752 16756 16792]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$linkalldeplibs")
                                                                    )
                                                                  } {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [16815]
                                                                )
                                                              ]
                                                              spids: [16815]
                                                            )
                                                          ]
                                                          spids: [-1 16812]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdependency_libs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$deplib") (" ") 
                                                                    ($ VSub_Name 
"$newdependency_libs"
                                                                    )
                                                                  )
                                                                }
                                                              spids: [16834]
                                                            )
                                                          ]
                                                          spids: [16834]
                                                        )
                                                      ]
                                                      spids: [16823 16842]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ (X) 
                                                                      ($ VSub_Name "$duplicate_deps")
                                                                    )
                                                                  } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$tmp_libs") (" "))
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$deplib") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: specialdeplibs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$specialdeplibs"
                                                                                ) (" ") ($ VSub_Name "$deplib")
                                                                              )
                                                                            }
                                                                          spids: [16884]
                                                                        )
                                                                      ]
                                                                      spids: [16884]
                                                                    )
                                                                  ]
                                                                  spids: [16875 16882 16891 -1]
                                                                )
                                                              ]
                                                              spids: [16865 16872 16894]
                                                            )
                                                          ]
                                                          spids: [-1 16862]
                                                        )
                                                      ]
                                                      spids: [-1 16897]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tmp_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$tmp_libs") (" ") 
                                                                ($ VSub_Name "$deplib")
                                                              )
                                                            }
                                                          spids: [16900]
                                                        )
                                                      ]
                                                      spids: [16900]
                                                    )
                                                  ]
                                                  spids: [16749 16908]
                                                )
                                              spids: [16745 16747]
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [-1 16665]
                                        )
                                      ]
                                      spids: [-1 16917]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} 
                                                  {
                                                    (DQ ($ VSub_Name "$linkmode") (",") 
                                                      ($ VSub_Name "$pass")
                                                    )
                                                  } {(Lit_Other "=")} {(DQ ("prog,link"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$library_names"))}
                                                            )
                                                            (BraceGroup
                                                              children: [
                                                                (Sentence
                                                                  child: 
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$prefer_static_libs"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$old_library"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      ]
                                                                      op_id: Op_DPipe
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              spids: [16957]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$shlibpath_var"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(test)} {(-z)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$avoidtemprpath"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$temp_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") ($ VSub_Name "$dir") 
                                                                        (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17029 17036 17038 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$absdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17041 17048 17050 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: temp_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$temp_rpath"
                                                                                ) (" ") ($ VSub_Name "$absdir")
                                                                              )
                                                                            }
                                                                          spids: [17056]
                                                                        )
                                                                      ]
                                                                      spids: [17056]
                                                                    )
                                                                  ]
                                                                  spids: [17053 17054 17063 -1]
                                                                )
                                                              ]
                                                              spids: [17019 17026 17066]
                                                            )
                                                          ]
                                                          spids: [-1 17012]
                                                        )
                                                      ]
                                                      spids: [-1 17069]
                                                    )
                                                    (Case
                                                      to_match: 
                                                        {
                                                          (DQ (" ") 
                                                            ($ VSub_Name "$sys_lib_dlsearch_path") (" ")
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$absdir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [17096 17103 17105 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$compile_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$absdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17122 17129 17131 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: compile_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$compile_rpath"
                                                                                ) (" ") ($ VSub_Name "$absdir")
                                                                              )
                                                                            }
                                                                          spids: [17137]
                                                                        )
                                                                      ]
                                                                      spids: [17137]
                                                                    )
                                                                  ]
                                                                  spids: [17134 17135 -1 17145]
                                                                )
                                                              ]
                                                              spids: [17112 17119 17145]
                                                            )
                                                          ]
                                                          spids: [17108 17109 17148 -1]
                                                        )
                                                      ]
                                                      spids: [17085 17093 17151]
                                                    )
                                                    (Case
                                                      to_match: 
                                                        {
                                                          (DQ (" ") 
                                                            ($ VSub_Name "$sys_lib_dlsearch_path") (" ")
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [17165 17172 17174 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$finalize_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$libdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17191 17198 17200 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: finalize_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$finalize_rpath"
                                                                                ) (" ") ($ VSub_Name "$libdir")
                                                                              )
                                                                            }
                                                                          spids: [17206]
                                                                        )
                                                                      ]
                                                                      spids: [17206]
                                                                    )
                                                                  ]
                                                                  spids: [17203 17204 -1 17214]
                                                                )
                                                              ]
                                                              spids: [17181 17188 17214]
                                                            )
                                                          ]
                                                          spids: [17177 17178 17217 -1]
                                                        )
                                                      ]
                                                      spids: [17154 17162 17220]
                                                    )
                                                  ]
                                                  spids: [-1 16983]
                                                )
                                              ]
                                              spids: [-1 17223]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$alldeplibs"))} {(Lit_Other "=")} {(yes)}
                                                            )
                                                            (BraceGroup
                                                              children: [
                                                                (Sentence
                                                                  child: 
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$deplibs_check_method"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(pass_all)}
                                                                        )
                                                                        (BraceGroup
                                                                          children: [
                                                                            (Sentence
                                                                              child: 
                                                                                (AndOr
                                                                                  children: [
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$build_libtool_libs"
                                                                                          )
                                                                                        )
                                                                                      } {(Lit_Other "=")} {(yes)}
                                                                                    )
                                                                                    (C {(test)} {(-n)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$library_names"
                                                                                          )
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                  ]
                                                                                  op_id: Op_DAmp
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          spids: [17260]
                                                                        )
                                                                      ]
                                                                      op_id: Op_DPipe
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              spids: [17245]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [-1 17290]
                                                )
                                              ]
                                              spids: [-1 17300]
                                            )
                                          ]
                                          spids: [-1 16941]
                                        )
                                      ]
                                      spids: [-1 17303]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_static)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [17307]
                                        )
                                      ]
                                      spids: [17307]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:use_static_libs)
                                          op: Equal
                                          rhs: {($ VSub_Name "$prefer_static_libs")}
                                          spids: [17314]
                                        )
                                      ]
                                      spids: [17314]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$use_static_libs"))} 
                                                      {(Lit_Other "=")} {(built)}
                                                    )
                                                    (C {(test)} {(DQ ($ VSub_Name "$installed"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:use_static_libs)
                                                  op: Equal
                                                  rhs: {(no)}
                                                  spids: [17347]
                                                )
                                              ]
                                              spids: [17347]
                                            )
                                          ]
                                          spids: [-1 17344]
                                        )
                                      ]
                                      spids: [-1 17351]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$library_names"))}
                                                    )
                                                    (BraceGroup
                                                      children: [
                                                        (Sentence
                                                          child: 
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$use_static_libs")
                                                                    )
                                                                  } {(Lit_Other "=")} {(no)}
                                                                )
                                                                (C {(test)} {(-z)} 
                                                                  {(DQ ($ VSub_Name "$old_library"))}
                                                                )
                                                              ]
                                                              op_id: Op_DPipe
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      spids: [17367]
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$installed"))} 
                                                          {(Lit_Other "=")} {(no)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:notinst_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$notinst_deplibs") 
                                                                (" ") ($ VSub_Name "$lib")
                                                              )
                                                            }
                                                          spids: [17412]
                                                        )
                                                      ]
                                                      spids: [17412]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:need_relink)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                          spids: [17420]
                                                        )
                                                      ]
                                                      spids: [17420]
                                                    )
                                                  ]
                                                  spids: [-1 17409]
                                                )
                                              ]
                                              spids: [-1 17424]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$shouldnotlink"))} {(Lit_Other "=")} {(yes)}
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                              {(Lit_Other "=")} {(link)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$echo")})
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} {(prog)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** Warning: Linking the executable "
                                                                  ) ($ VSub_Name "$output") (" against the loadable module")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 17485]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** Warning: Linking the shared library "
                                                              ) ($ VSub_Name "$output") (" against the loadable module")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      spids: [17497 17509]
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ ("*** ") ($ VSub_Name "$linklib") 
                                                          (" is not portable!")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [-1 17466]
                                                )
                                              ]
                                              spids: [-1 17521]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(Lit_Other "=")} {(lib)}
                                                            )
                                                            (C {(test)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name "$hardcode_into_libs")
                                                                )
                                                              } {(Lit_Other "=")} {(yes)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Case
                                                      to_match: 
                                                        {
                                                          (DQ (" ") 
                                                            ($ VSub_Name "$sys_lib_dlsearch_path") (" ")
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$absdir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [17576 17583 17585 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$compile_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$absdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17602 17609 17611 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: compile_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$compile_rpath"
                                                                                ) (" ") ($ VSub_Name "$absdir")
                                                                              )
                                                                            }
                                                                          spids: [17617]
                                                                        )
                                                                      ]
                                                                      spids: [17617]
                                                                    )
                                                                  ]
                                                                  spids: [17614 17615 -1 17625]
                                                                )
                                                              ]
                                                              spids: [17592 17599 17625]
                                                            )
                                                          ]
                                                          spids: [17588 17589 17628 -1]
                                                        )
                                                      ]
                                                      spids: [17565 17573 17631]
                                                    )
                                                    (Case
                                                      to_match: 
                                                        {
                                                          (DQ (" ") 
                                                            ($ VSub_Name "$sys_lib_dlsearch_path") (" ")
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [17645 17652 17654 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$finalize_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$libdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [17671 17678 17680 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: finalize_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$finalize_rpath"
                                                                                ) (" ") ($ VSub_Name "$libdir")
                                                                              )
                                                                            }
                                                                          spids: [17686]
                                                                        )
                                                                      ]
                                                                      spids: [17686]
                                                                    )
                                                                  ]
                                                                  spids: [17683 17684 -1 17694]
                                                                )
                                                              ]
                                                              spids: [17661 17668 17694]
                                                            )
                                                          ]
                                                          spids: [17657 17658 17697 -1]
                                                        )
                                                      ]
                                                      spids: [17634 17642 17700]
                                                    )
                                                  ]
                                                  spids: [-1 17550]
                                                )
                                              ]
                                              spids: [-1 17703]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name 
"$old_archive_from_expsyms_cmds"
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(set)} {(dummy)} 
                                                      {($ VSub_Name "$library_names")}
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:realname)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Number "$2"))}
                                                          spids: [17732]
                                                        )
                                                      ]
                                                      spids: [17732]
                                                    )
                                                    (Sentence
                                                      child: (C {(shift)})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                    (C {(shift)})
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libname)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (C {(eval)} 
                                                                        {
                                                                          (EscapedLiteralPart
                                                                            token: 
                                                                              <Lit_EscapedChar 
"\\\\"
                                                                              >
                                                                          ) ($ VSub_Name "$echo")
                                                                        } 
                                                                        {
                                                                          (EscapedLiteralPart
                                                                            token: 
                                                                              <Lit_EscapedChar 
"\\\""
                                                                              >
                                                                          ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                        }
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [17745 17754]
                                                              )
                                                            }
                                                          spids: [17744]
                                                        )
                                                      ]
                                                      spids: [17744]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$dlname"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:soname)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$dlname"))}
                                                                  spids: [17775]
                                                                )
                                                              ]
                                                              spids: [17775]
                                                            )
                                                          ]
                                                          spids: [-1 17772]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$soname_spec"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: {($ VSub_Name "$host")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") (cygwin) 
                                                                      (Lit_Other "*")
                                                                    }
                                                                    {(mingw) (Lit_Other "*")}
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:major)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (C {(expr)} 
                                                                                        {
                                                                                          ($ 
VSub_Name "$current"
                                                                                          )
                                                                                        } {(-)} {($ VSub_Name "$age")}
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [17818 17826]
                                                                              )
                                                                            }
                                                                          spids: [17817]
                                                                        )
                                                                      ]
                                                                      spids: [17817]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: versuffix
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-) 
                                                                                ($ VSub_Name "$major")
                                                                              )
                                                                            }
                                                                          spids: [17829]
                                                                        )
                                                                      ]
                                                                      spids: [17829]
                                                                    )
                                                                  ]
                                                                  spids: [17806 17814 17836 -1]
                                                                )
                                                              ]
                                                              spids: [17799 17803 17839]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "soname=") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$soname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              }
                                                            )
                                                          ]
                                                          spids: [17781 17792]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:soname)
                                                              op: Equal
                                                              rhs: {(DQ ($ VSub_Name "$realname"))}
                                                              spids: [17853]
                                                            )
                                                          ]
                                                          spids: [17853]
                                                        )
                                                      ]
                                                      spids: [17850 17859]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:soroot)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$soname"))}
                                                          spids: [17867]
                                                        )
                                                      ]
                                                      spids: [17867]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:soname)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              ($ VSub_Name "$soroot")
                                                                            }
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(-e)} {(SQ <"s/^.*\\///">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [17874 17890]
                                                              )
                                                            }
                                                          spids: [17873]
                                                        )
                                                      ]
                                                      spids: [17873]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newlib)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ (libimp-) 
                                                                (CommandSubPart
                                                                  command_list: 
                                                                    (CommandList
                                                                      children: [
                                                                        (Pipeline
                                                                          children: [
                                                                            (C {($ VSub_Name "$echo")} 
                                                                              {
                                                                                ($ VSub_Name 
"$soname"
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(${ VSub_Name SED)} 
                                                                              {
                                                                                (SQ 
                                                                                  <
"s/^lib//;s/\\.dll$//"
                                                                                  >
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          negated: False
                                                                        )
                                                                      ]
                                                                    )
                                                                  left_token: <Left_Backtick "`">
                                                                  spids: [17896 17910]
                                                                ) (.a)
                                                              )
                                                            }
                                                          spids: [17893]
                                                        )
                                                      ]
                                                      spids: [17893]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$soname") (-def)
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [(C {(Lit_Other ":")})]
                                                          spids: [-1 17934]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$show")} 
                                                          {
                                                            (DQ 
                                                              (
"extracting exported symbol list from "
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$soname") ("'")
                                                            )
                                                          }
                                                        )
                                                        (Sentence
                                                          child: 
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:save_ifs)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                                  spids: [17952]
                                                                )
                                                              ]
                                                              spids: [17952]
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:IFS)
                                                              op: Equal
                                                              rhs: {(SQ <"~">)}
                                                              spids: [17958]
                                                            )
                                                          ]
                                                          spids: [17958]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:cmds)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_Name 
"$extract_expsyms_cmds"
                                                                  )
                                                                }
                                                              spids: [17964]
                                                            )
                                                          ]
                                                          spids: [17964]
                                                        )
                                                        (ForEach
                                                          iter_name: cmd
                                                          iter_words: [{($ VSub_Name "$cmds")}]
                                                          do_arg_iter: False
                                                          body: 
                                                            (DoGroup
                                                              children: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:IFS)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$save_ifs")
                                                                          )
                                                                        }
                                                                      spids: [17980]
                                                                    )
                                                                  ]
                                                                  spids: [17980]
                                                                )
                                                                (C {(eval)} 
                                                                  {(Lit_VarLike "cmd=") 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar "\\\"">
                                                                    ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                  }
                                                                )
                                                                (C {($ VSub_Name "$show")} 
                                                                  {(DQ ($ VSub_Name "$cmd"))}
                                                                )
                                                                (AndOr
                                                                  children: [
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (C {(exit)} {($ VSub_QMark "$?")})
                                                                  ]
                                                                  op_id: Op_DPipe
                                                                )
                                                              ]
                                                              spids: [17977 18016]
                                                            )
                                                          spids: [17973 17975]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:IFS)
                                                              op: Equal
                                                              rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                              spids: [18019]
                                                            )
                                                          ]
                                                          spids: [18019]
                                                        )
                                                      ]
                                                      spids: [17939 18025]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$newlib")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Sentence
                                                              child: (C {(Lit_Other ":")})
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          spids: [-1 18046]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$show")} 
                                                          {
                                                            (DQ ("generating import library for ") 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\`">
                                                              ) ($ VSub_Name "$soname") ("'")
                                                            )
                                                          }
                                                        )
                                                        (Sentence
                                                          child: 
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:save_ifs)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                                  spids: [18064]
                                                                )
                                                              ]
                                                              spids: [18064]
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:IFS)
                                                              op: Equal
                                                              rhs: {(SQ <"~">)}
                                                              spids: [18070]
                                                            )
                                                          ]
                                                          spids: [18070]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:cmds)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_Name 
"$old_archive_from_expsyms_cmds"
                                                                  )
                                                                }
                                                              spids: [18076]
                                                            )
                                                          ]
                                                          spids: [18076]
                                                        )
                                                        (ForEach
                                                          iter_name: cmd
                                                          iter_words: [{($ VSub_Name "$cmds")}]
                                                          do_arg_iter: False
                                                          body: 
                                                            (DoGroup
                                                              children: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:IFS)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$save_ifs")
                                                                          )
                                                                        }
                                                                      spids: [18092]
                                                                    )
                                                                  ]
                                                                  spids: [18092]
                                                                )
                                                                (C {(eval)} 
                                                                  {(Lit_VarLike "cmd=") 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar "\\\"">
                                                                    ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                  }
                                                                )
                                                                (C {($ VSub_Name "$show")} 
                                                                  {(DQ ($ VSub_Name "$cmd"))}
                                                                )
                                                                (AndOr
                                                                  children: [
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (C {(exit)} {($ VSub_QMark "$?")})
                                                                  ]
                                                                  op_id: Op_DPipe
                                                                )
                                                              ]
                                                              spids: [18089 18128]
                                                            )
                                                          spids: [18085 18087]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:IFS)
                                                              op: Equal
                                                              rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                              spids: [18131]
                                                            )
                                                          ]
                                                          spids: [18131]
                                                        )
                                                      ]
                                                      spids: [18051 18137]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dir)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$output_objdir")}
                                                          spids: [18144]
                                                        )
                                                      ]
                                                      spids: [18144]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:linklib)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$newlib")}
                                                          spids: [18148]
                                                        )
                                                      ]
                                                      spids: [18148]
                                                    )
                                                  ]
                                                  spids: [-1 17718]
                                                )
                                              ]
                                              spids: [-1 18152]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(Lit_Other "=")} {(prog)}
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                              {(KW_Bang "!") (Lit_Other "=")} {(relink)}
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add_shlibpath)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18188]
                                                        )
                                                      ]
                                                      spids: [18188]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add_dir)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18191]
                                                        )
                                                      ]
                                                      spids: [18191]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18194]
                                                        )
                                                      ]
                                                      spids: [18194]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:lib_linked)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                          spids: [18197]
                                                        )
                                                      ]
                                                      spids: [18197]
                                                    )
                                                    (Case
                                                      to_match: {($ VSub_Name "$hardcode_action")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(immediate)} {(unsupported)}]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_direct"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$linklib")
                                                                              )
                                                                            }
                                                                          spids: [18232]
                                                                        )
                                                                      ]
                                                                      spids: [18232]
                                                                    )
                                                                    (Case
                                                                      to_match: 
                                                                        {($ VSub_Name "$host")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-sco3.2v5.0.) (Lit_Other "[") (024) (Lit_Other "]") (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: add_dir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ (-L) 
                                                                                        ($ VSub_Name 
"$dir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [18257]
                                                                                )
                                                                              ]
                                                                              spids: [18257]
                                                                            )
                                                                          ]
                                                                          spids: [18247 18255 18263 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-sysv4) (Lit_Other "*") (uw2) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: add_dir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ (-L) 
                                                                                        ($ VSub_Name 
"$dir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [18275]
                                                                                )
                                                                              ]
                                                                              spids: [18275]
                                                                            )
                                                                          ]
                                                                          spids: [18266 18273 18281 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-sysv5OpenUNIX) (Lit_Other "*")
                                                                            }
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-sysv5UnixWare7.) (Lit_Other "[") (01) (Lit_Other "]") (.) (Lit_Other "[") (10) (Lit_Other "]") 
                                                                              (Lit_Other "*")
                                                                            }
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-unixware7) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: add_dir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ (-L) 
                                                                                        ($ VSub_Name 
"$dir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [18316]
                                                                                )
                                                                              ]
                                                                              spids: [18316]
                                                                            )
                                                                          ]
                                                                          spids: [18284 18314 18322 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-darwin) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (Pipeline
                                                                                          children: [
                                                                                            (SimpleCommand
                                                                                              words: [
                                                                                                {
                                                                                                  (
/usr/bin/file
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (
-L
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  ($ 
VSub_Name "$add"
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (Redir
                                                                                                  op_id: 
Redir_Great
                                                                                                  fd: 
2
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
18350
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (SimpleCommand
                                                                                              words: [
                                                                                                {
                                                                                                  ($ 
VSub_Name "$EGREP"
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    (
": [^:]* bundle"
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (Redir
                                                                                                  op_id: 
Redir_Great
                                                                                                  fd: 
-1
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
18363
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          negated: 
False
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("** Warning, lib ") ($ VSub_Name "$linklib") (" is a module, not a shared library"))}
                                                                                    )
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (C 
                                                                                                  {
                                                                                                    (
test
                                                                                                    )
                                                                                                  } {(-z)} {(DQ ($ VSub_Name "$old_library"))}
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_Name "$echo"
                                                                                                )
                                                                                              }
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_Name "$echo"
                                                                                                )
                                                                                              } {(DQ ("** And there doesn't seem to be a static archive available"))}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_Name "$echo"
                                                                                                )
                                                                                              } {(DQ ("** The link will probably fail, sorry"))}
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
18392
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      else_action: [
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
add
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$dir"
                                                                                                    ) (/) ($ VSub_Name "$old_library")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
18415
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
18415
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
18412
18423
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 18368]
                                                                                )
                                                                              ]
                                                                              spids: [-1 18426]
                                                                            )
                                                                          ]
                                                                          spids: [18325 18331 -1 18429]
                                                                        )
                                                                      ]
                                                                      spids: [18240 18244 18429]
                                                                    )
                                                                  ]
                                                                  spids: [-1 18229]
                                                                )
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_minus_L"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {($ VSub_Name "$host")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-sunos) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
add_shlibpath
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$dir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [18462]
                                                                                )
                                                                              ]
                                                                              spids: [18462]
                                                                            )
                                                                          ]
                                                                          spids: [18455 18460 18467 -1]
                                                                        )
                                                                      ]
                                                                      spids: [18448 18452 18470]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add_dir)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-L) 
                                                                                ($ VSub_Name "$dir")
                                                                              )
                                                                            }
                                                                          spids: [18473]
                                                                        )
                                                                      ]
                                                                      spids: [18473]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-l) 
                                                                                ($ VSub_Name "$name")
                                                                              )
                                                                            }
                                                                          spids: [18480]
                                                                        )
                                                                      ]
                                                                      spids: [18480]
                                                                    )
                                                                  ]
                                                                  spids: [18432 18445]
                                                                )
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_shlibpath_var"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: add_shlibpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$dir")
                                                                              )
                                                                            }
                                                                          spids: [18503]
                                                                        )
                                                                      ]
                                                                      spids: [18503]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-l) 
                                                                                ($ VSub_Name "$name")
                                                                              )
                                                                            }
                                                                          spids: [18509]
                                                                        )
                                                                      ]
                                                                      spids: [18509]
                                                                    )
                                                                  ]
                                                                  spids: [18487 18500]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:lib_linked)
                                                                      op: Equal
                                                                      rhs: {(no)}
                                                                      spids: [18519]
                                                                    )
                                                                  ]
                                                                  spids: [18519]
                                                                )
                                                              ]
                                                              spids: [18516 18523]
                                                            )
                                                          ]
                                                          spids: [18208 18213 18526 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(relink)}]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_direct"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(yes)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$linklib")
                                                                              )
                                                                            }
                                                                          spids: [18549]
                                                                        )
                                                                      ]
                                                                      spids: [18549]
                                                                    )
                                                                  ]
                                                                  spids: [-1 18546]
                                                                )
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_minus_L"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(yes)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add_dir)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-L) 
                                                                                ($ VSub_Name "$dir")
                                                                              )
                                                                            }
                                                                          spids: [18573]
                                                                        )
                                                                      ]
                                                                      spids: [18573]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-n)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$inst_prefix_dir"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Case
                                                                              to_match: 
                                                                                {
                                                                                  ($ VSub_Name 
"$libdir"
                                                                                  )
                                                                                }
                                                                              arms: [
                                                                                (case_arm
                                                                                  pat_list: [
                                                                                    {
                                                                                      (Lit_Other 
"["
                                                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                                                                    }
                                                                                  ]
                                                                                  action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
add_dir
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$add_dir"
                                                                                                ) (" -L") ($ VSub_Name "$inst_prefix_dir") ($ VSub_Name "$libdir")
                                                                                              )
                                                                                            }
                                                                                          spids: [
18613
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [18613]
                                                                                    )
                                                                                  ]
                                                                                  spids: [
18605
18610
18622
-1
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              spids: [
18598
18602
18625
                                                                              ]
                                                                            )
                                                                          ]
                                                                          spids: [-1 18595]
                                                                        )
                                                                      ]
                                                                      spids: [-1 18628]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-l) 
                                                                                ($ VSub_Name "$name")
                                                                              )
                                                                            }
                                                                          spids: [18631]
                                                                        )
                                                                      ]
                                                                      spids: [18631]
                                                                    )
                                                                  ]
                                                                  spids: [18557 18570]
                                                                )
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_shlibpath_var"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(yes)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: add_shlibpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$dir")
                                                                              )
                                                                            }
                                                                          spids: [18654]
                                                                        )
                                                                      ]
                                                                      spids: [18654]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ (-l) 
                                                                                ($ VSub_Name "$name")
                                                                              )
                                                                            }
                                                                          spids: [18660]
                                                                        )
                                                                      ]
                                                                      spids: [18660]
                                                                    )
                                                                  ]
                                                                  spids: [18638 18651]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:lib_linked)
                                                                      op: Equal
                                                                      rhs: {(no)}
                                                                      spids: [18670]
                                                                    )
                                                                  ]
                                                                  spids: [18670]
                                                                )
                                                              ]
                                                              spids: [18667 18674]
                                                            )
                                                          ]
                                                          spids: [18529 18530 18677 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:lib_linked)
                                                                  op: Equal
                                                                  rhs: {(no)}
                                                                  spids: [18683]
                                                                )
                                                              ]
                                                              spids: [18683]
                                                            )
                                                          ]
                                                          spids: [18680 18681 18686 -1]
                                                        )
                                                      ]
                                                      spids: [18201 18205 18689]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$lib_linked"))} {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ ($ VSub_Name "$modename") 
                                                                  (
": configuration error: unsupported hardcode properties"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                          ]
                                                          spids: [-1 18707]
                                                        )
                                                      ]
                                                      spids: [-1 18723]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$add_shlibpath")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {(Lit_Other ":") 
                                                                  ($ VSub_Name "$compile_shlibpath") (Lit_Other ":")
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (":") 
                                                                        ($ VSub_Name "$add_shlibpath") (":")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [18750 18757 18759 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: 
compile_shlibpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$compile_shlibpath"
                                                                                ) ($ VSub_Name "$add_shlibpath") (":")
                                                                              )
                                                                            }
                                                                          spids: [18765]
                                                                        )
                                                                      ]
                                                                      spids: [18765]
                                                                    )
                                                                  ]
                                                                  spids: [18762 18763 18772 -1]
                                                                )
                                                              ]
                                                              spids: [18741 18747 18775]
                                                            )
                                                          ]
                                                          spids: [-1 18738]
                                                        )
                                                      ]
                                                      spids: [-1 18778]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} {(prog)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$add_dir"))}
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: compile_deplibs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$add_dir") (" ") ($ VSub_Name "$compile_deplibs")
                                                                          )
                                                                        }
                                                                      spids: [18807]
                                                                    )
                                                                  ]
                                                                  spids: [18807]
                                                                )
                                                              ]
                                                              op_id: Op_DAmp
                                                            )
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$add"))}
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: compile_deplibs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ ($ VSub_Name "$add") 
                                                                            (" ") ($ VSub_Name "$compile_deplibs")
                                                                          )
                                                                        }
                                                                      spids: [18825]
                                                                    )
                                                                  ]
                                                                  spids: [18825]
                                                                )
                                                              ]
                                                              op_id: Op_DAmp
                                                            )
                                                          ]
                                                          spids: [-1 18794]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$add_dir"))}
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$add_dir") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [18846]
                                                                )
                                                              ]
                                                              spids: [18846]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$add"))}
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$add") (" ") 
                                                                        ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [18864]
                                                                )
                                                              ]
                                                              spids: [18864]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                        (If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (Sentence
                                                                  child: 
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_direct"
                                                                              )
                                                                            )
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                        )
                                                                        (AndOr
                                                                          children: [
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$hardcode_minus_L"
                                                                                  )
                                                                                )
                                                                              } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$hardcode_shlibpath_var"
                                                                                  )
                                                                                )
                                                                              } {(Lit_Other "=")} {(yes)}
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      ]
                                                                      op_id: Op_DAmp
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              action: [
                                                                (Case
                                                                  to_match: 
                                                                    {(Lit_Other ":") 
                                                                      ($ VSub_Name 
"$finalize_shlibpath"
                                                                      ) (Lit_Other ":")
                                                                    }
                                                                  arms: [
                                                                    (case_arm
                                                                      pat_list: [
                                                                        {(Lit_Other "*") 
                                                                          (DQ (":") 
                                                                            ($ VSub_Name "$libdir") (":")
                                                                          ) (Lit_Other "*")
                                                                        }
                                                                      ]
                                                                      spids: [18927 18934 18936 -1]
                                                                    )
                                                                    (case_arm
                                                                      pat_list: [{(Lit_Other "*")}]
                                                                      action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: 
finalize_shlibpath
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$finalize_shlibpath"
                                                                                    ) ($ VSub_Name "$libdir") (":")
                                                                                  )
                                                                                }
                                                                              spids: [18942]
                                                                            )
                                                                          ]
                                                                          spids: [18942]
                                                                        )
                                                                      ]
                                                                      spids: [18939 18940 18949 -1]
                                                                    )
                                                                  ]
                                                                  spids: [18918 18924 18952]
                                                                )
                                                              ]
                                                              spids: [-1 18915]
                                                            )
                                                          ]
                                                          spids: [-1 18955]
                                                        )
                                                      ]
                                                      spids: [18833 18958]
                                                    )
                                                  ]
                                                  spids: [-1 18185]
                                                )
                                              ]
                                              spids: [-1 18961]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                              {(Lit_Other "=")} {(prog)}
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                              {(Lit_Other "=")} {(relink)}
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add_shlibpath)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18993]
                                                        )
                                                      ]
                                                      spids: [18993]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add_dir)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18996]
                                                        )
                                                      ]
                                                      spids: [18996]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:add)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [18999]
                                                        )
                                                      ]
                                                      spids: [18999]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$hardcode_direct")
                                                                    )
                                                                  } {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$libdir") (/) 
                                                                        ($ VSub_Name "$linklib")
                                                                      )
                                                                    }
                                                                  spids: [19022]
                                                                )
                                                              ]
                                                              spids: [19022]
                                                            )
                                                          ]
                                                          spids: [-1 19019]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_minus_L"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:add_dir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ (-L) ($ VSub_Name "$libdir"))
                                                                    }
                                                                  spids: [19046]
                                                                )
                                                              ]
                                                              spids: [19046]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(DQ (-l) ($ VSub_Name "$name"))}
                                                                  spids: [19053]
                                                                )
                                                              ]
                                                              spids: [19053]
                                                            )
                                                          ]
                                                          spids: [19030 19043]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_shlibpath_var"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {(Lit_Other ":") 
                                                                  ($ VSub_Name "$finalize_shlibpath") (Lit_Other ":")
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (":") 
                                                                        ($ VSub_Name "$libdir") (":")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [19085 19092 19094 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: 
finalize_shlibpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$finalize_shlibpath"
                                                                                ) ($ VSub_Name "$libdir") (":")
                                                                              )
                                                                            }
                                                                          spids: [19100]
                                                                        )
                                                                      ]
                                                                      spids: [19100]
                                                                    )
                                                                  ]
                                                                  spids: [19097 19098 19107 -1]
                                                                )
                                                              ]
                                                              spids: [19076 19082 19110]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(DQ (-l) ($ VSub_Name "$name"))}
                                                                  spids: [19113]
                                                                )
                                                              ]
                                                              spids: [19113]
                                                            )
                                                          ]
                                                          spids: [19060 19073]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_automatic"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (AndOr
                                                                          children: [
                                                                            (C {(test)} {(-n)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$inst_prefix_dir"
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(test)} {(-f)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$inst_prefix_dir"
                                                                                  ) ($ VSub_Name "$libdir") (/) ($ VSub_Name "$linklib")
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:add)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$inst_prefix_dir"
                                                                                ) ($ VSub_Name "$libdir") (/) ($ VSub_Name "$linklib")
                                                                              )
                                                                            }
                                                                          spids: [19165]
                                                                        )
                                                                      ]
                                                                      spids: [19165]
                                                                    )
                                                                  ]
                                                                  spids: [-1 19162]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:add)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ ($ VSub_Name "$libdir") 
                                                                            (/) ($ VSub_Name "$linklib")
                                                                          )
                                                                        }
                                                                      spids: [19177]
                                                                    )
                                                                  ]
                                                                  spids: [19177]
                                                                )
                                                              ]
                                                              spids: [19174 19185]
                                                            )
                                                          ]
                                                          spids: [19120 19133]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:add_dir)
                                                              op: Equal
                                                              rhs: {(DQ (-L) ($ VSub_Name "$libdir"))}
                                                              spids: [19195]
                                                            )
                                                          ]
                                                          spids: [19195]
                                                        )
                                                        (If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (Sentence
                                                                  child: 
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$inst_prefix_dir"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              action: [
                                                                (Case
                                                                  to_match: {($ VSub_Name "$libdir")}
                                                                  arms: [
                                                                    (case_arm
                                                                      pat_list: [
                                                                        {(Lit_Other "[") 
                                                                          (EscapedLiteralPart
                                                                            token: 
                                                                              <Lit_EscapedChar 
"\\\\"
                                                                              >
                                                                          ) (/) (Lit_Other "]") (Lit_Other "*")
                                                                        }
                                                                      ]
                                                                      action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: add_dir
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$add_dir"
                                                                                    ) (" -L") ($ VSub_Name "$inst_prefix_dir") ($ VSub_Name "$libdir")
                                                                                  )
                                                                                }
                                                                              spids: [19235]
                                                                            )
                                                                          ]
                                                                          spids: [19235]
                                                                        )
                                                                      ]
                                                                      spids: [19227 19232 19244 -1]
                                                                    )
                                                                  ]
                                                                  spids: [19220 19224 19247]
                                                                )
                                                              ]
                                                              spids: [-1 19217]
                                                            )
                                                          ]
                                                          spids: [-1 19250]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:add)
                                                              op: Equal
                                                              rhs: {(DQ (-l) ($ VSub_Name "$name"))}
                                                              spids: [19253]
                                                            )
                                                          ]
                                                          spids: [19253]
                                                        )
                                                      ]
                                                      spids: [19188 19260]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} {(prog)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$add_dir"))}
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: finalize_deplibs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$add_dir") (" ") ($ VSub_Name "$finalize_deplibs")
                                                                          )
                                                                        }
                                                                      spids: [19290]
                                                                    )
                                                                  ]
                                                                  spids: [19290]
                                                                )
                                                              ]
                                                              op_id: Op_DAmp
                                                            )
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$add"))}
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: finalize_deplibs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ ($ VSub_Name "$add") 
                                                                            (" ") ($ VSub_Name "$finalize_deplibs")
                                                                          )
                                                                        }
                                                                      spids: [19308]
                                                                    )
                                                                  ]
                                                                  spids: [19308]
                                                                )
                                                              ]
                                                              op_id: Op_DAmp
                                                            )
                                                          ]
                                                          spids: [-1 19277]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$add_dir"))}
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$add_dir") 
                                                                        (" ") ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [19329]
                                                                )
                                                              ]
                                                              spids: [19329]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$add"))}
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$add") (" ") 
                                                                        ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  spids: [19347]
                                                                )
                                                              ]
                                                              spids: [19347]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      ]
                                                      spids: [19316 19355]
                                                    )
                                                  ]
                                                  spids: [-1 18990]
                                                )
                                              ]
                                              spids: [-1 19358]
                                            )
                                          ]
                                          spids: [-1 17393]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                  {(Lit_Other "=")} {(prog)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_Name "$hardcode_direct"))} {(KW_Bang "!") (Lit_Other "=")} {(unsupported)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$old_library"))}
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:linklib)
                                                              op: Equal
                                                              rhs: {(DQ ($ VSub_Name "$old_library"))}
                                                              spids: [19416]
                                                            )
                                                          ]
                                                          spids: [19416]
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:compile_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dir") (/) 
                                                                ($ VSub_Name "$linklib") (" ") ($ VSub_Name "$compile_deplibs")
                                                              )
                                                            }
                                                          spids: [19422]
                                                        )
                                                      ]
                                                      spids: [19422]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dir") (/) 
                                                                ($ VSub_Name "$linklib") (" ") ($ VSub_Name "$finalize_deplibs")
                                                              )
                                                            }
                                                          spids: [19432]
                                                        )
                                                      ]
                                                      spids: [19432]
                                                    )
                                                  ]
                                                  spids: [-1 19403]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:compile_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ (-l) ($ VSub_Name "$name") (" -L") 
                                                            ($ VSub_Name "$dir") (" ") ($ VSub_Name "$compile_deplibs")
                                                          )
                                                        }
                                                      spids: [19445]
                                                    )
                                                  ]
                                                  spids: [19445]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:finalize_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ (-l) ($ VSub_Name "$name") (" -L") 
                                                            ($ VSub_Name "$dir") (" ") ($ VSub_Name "$finalize_deplibs")
                                                          )
                                                        }
                                                      spids: [19456]
                                                    )
                                                  ]
                                                  spids: [19456]
                                                )
                                              ]
                                              spids: [19442 19467]
                                            )
                                          ]
                                          spids: [19361 19374]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {
                                                            (DQ ($ VSub_Name "$deplibs_check_method"))
                                                          } {(KW_Bang "!") (Lit_Other "=")} {(pass_all)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$echo")})
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** Warning: This system can not link to static lib archive "
                                                          ) ($ VSub_Name "$lib") (.)
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** I have the capability to make that library automatically link in when"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** you link to this library.  But I can only do this if you have a"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** shared version of the library, which you do not appear to have."
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {(DQ ($ VSub_Name "$module"))} {(Lit_Other "=")} {(yes)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** But as you try to build a module library, libtool will still create "
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** a static module, that should work as long as the dlopening application"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** is linked with the -dlopen flag to resolve symbols at runtime."
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$global_symbol_pipe"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_Name "$echo")})
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** However, this would only work if libtool was able to extract symbol"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** lists from a program, using "
                                                                          ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("nm' or equivalent, but libtool could")
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** not find such a program.  So, this module is probably useless."
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ ("*** ") 
                                                                          (EscapedLiteralPart
                                                                            token: 
                                                                              <Lit_EscapedChar 
"\\`"
                                                                              >
                                                                          ) ("nm' from GNU binutils and a full rebuild may help.")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 19605]
                                                                )
                                                              ]
                                                              spids: [-1 19643]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$build_old_libs"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(no)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: 
build_libtool_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(module)}
                                                                          spids: [19662]
                                                                        )
                                                                      ]
                                                                      spids: [19662]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: build_old_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(yes)}
                                                                          spids: [19666]
                                                                        )
                                                                      ]
                                                                      spids: [19666]
                                                                    )
                                                                  ]
                                                                  spids: [-1 19659]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: build_libtool_libs
                                                                        )
                                                                      op: Equal
                                                                      rhs: {(no)}
                                                                      spids: [19673]
                                                                    )
                                                                  ]
                                                                  spids: [19673]
                                                                )
                                                              ]
                                                              spids: [19670 19677]
                                                            )
                                                          ]
                                                          spids: [-1 19570]
                                                        )
                                                      ]
                                                      spids: [-1 19680]
                                                    )
                                                  ]
                                                  spids: [-1 19504]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$dir") (/) 
                                                            ($ VSub_Name "$old_library") (" ") ($ VSub_Name "$deplibs")
                                                          )
                                                        }
                                                      spids: [19686]
                                                    )
                                                  ]
                                                  spids: [19686]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:link_static)
                                                      op: Equal
                                                      rhs: {(yes)}
                                                      spids: [19696]
                                                    )
                                                  ]
                                                  spids: [19696]
                                                )
                                              ]
                                              spids: [19683 19700]
                                            )
                                          ]
                                          spids: [19470 19483]
                                        )
                                      ]
                                      spids: [-1 19703]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} 
                                                  {(Lit_Other "=")} {(lib)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$dependency_libs"))}
                                                            )
                                                            (BraceGroup
                                                              children: [
                                                                (Sentence
                                                                  child: 
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_into_libs"
                                                                              )
                                                                            )
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                        )
                                                                        (AndOr
                                                                          children: [
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$build_old_libs"
                                                                                  )
                                                                                )
                                                                              } {(Lit_Other "=")} {(yes)}
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$link_static"
                                                                                  )
                                                                                )
                                                                              } {(Lit_Other "=")} {(yes)}
                                                                            )
                                                                          ]
                                                                          op_id: Op_DPipe
                                                                        )
                                                                      ]
                                                                      op_id: Op_DPipe
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              spids: [19739]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:temp_deplibs)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [19789]
                                                        )
                                                      ]
                                                      spids: [19789]
                                                    )
                                                    (ForEach
                                                      iter_name: libdir
                                                      iter_words: [{($ VSub_Name "$dependency_libs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Case
                                                              to_match: {($ VSub_Name "$libdir")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [{(-R) (Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: temp_xrpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) ($ VSub_Name "$libdir"))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(SQ <"s/^-R//">)}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [19816 19833]
                                                                              )
                                                                            }
                                                                          spids: [19815]
                                                                        )
                                                                      ]
                                                                      spids: [19815]
                                                                    )
                                                                    (Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ (" ") 
                                                                            ($ VSub_Name "$xrpath") (" ")
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") 
                                                                              (DQ (" ") 
                                                                                ($ VSub_Name 
"$temp_xrpath"
                                                                                ) (" ")
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          spids: [19847 19854 19856 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: xrpath
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$xrpath"
                                                                                        ) (" ") ($ VSub_Name "$temp_xrpath")
                                                                                      )
                                                                                    }
                                                                                  spids: [19862]
                                                                                )
                                                                              ]
                                                                              spids: [19862]
                                                                            )
                                                                          ]
                                                                          spids: [19859 19860 19868 -1]
                                                                        )
                                                                      ]
                                                                      spids: [19836 19844 19871]
                                                                    )
                                                                  ]
                                                                  spids: [19811 19813 19872 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: temp_deplibs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$temp_deplibs"
                                                                                ) (" ") ($ VSub_Name "$libdir")
                                                                              )
                                                                            }
                                                                          spids: [19878]
                                                                        )
                                                                      ]
                                                                      spids: [19878]
                                                                    )
                                                                  ]
                                                                  spids: [19875 19876 19884 -1]
                                                                )
                                                              ]
                                                              spids: [19804 19808 19887]
                                                            )
                                                          ]
                                                          spids: [19801 19890]
                                                        )
                                                      spids: [19797 19799]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dependency_libs)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$temp_deplibs"))}
                                                          spids: [19893]
                                                        )
                                                      ]
                                                      spids: [19893]
                                                    )
                                                  ]
                                                  spids: [-1 19782]
                                                )
                                              ]
                                              spids: [-1 19899]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newlib_search_path)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$newlib_search_path") (" ") 
                                                        ($ VSub_Name "$absdir")
                                                      )
                                                    }
                                                  spids: [19903]
                                                )
                                              ]
                                              spids: [19903]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(DQ ($ VSub_Name "$link_static"))} 
                                                  {(Lit_Other "=")} {(no)}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:newdependency_libs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$abs_ladir") (/) 
                                                            ($ VSub_Name "$laname") (" ") ($ VSub_Name "$newdependency_libs")
                                                          )
                                                        }
                                                      spids: [19927]
                                                    )
                                                  ]
                                                  spids: [19927]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tmp_libs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [19941]
                                                )
                                              ]
                                              spids: [19941]
                                            )
                                            (ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_Name "$dependency_libs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdependency_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplib") (" ") 
                                                                ($ VSub_Name "$newdependency_libs")
                                                              )
                                                            }
                                                          spids: [19956]
                                                        )
                                                      ]
                                                      spids: [19956]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ (X) 
                                                                      ($ VSub_Name "$duplicate_deps")
                                                                    )
                                                                  } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$tmp_libs") (" "))
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$deplib") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: specialdeplibs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$specialdeplibs"
                                                                                ) (" ") ($ VSub_Name "$deplib")
                                                                              )
                                                                            }
                                                                          spids: [20003]
                                                                        )
                                                                      ]
                                                                      spids: [20003]
                                                                    )
                                                                  ]
                                                                  spids: [19994 20001 20010 -1]
                                                                )
                                                              ]
                                                              spids: [19984 19991 20013]
                                                            )
                                                          ]
                                                          spids: [-1 19981]
                                                        )
                                                      ]
                                                      spids: [-1 20016]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tmp_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$tmp_libs") (" ") 
                                                                ($ VSub_Name "$deplib")
                                                              )
                                                            }
                                                          spids: [20019]
                                                        )
                                                      ]
                                                      spids: [20019]
                                                    )
                                                  ]
                                                  spids: [19953 20027]
                                                )
                                              spids: [19949 19951]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_Name "$link_all_deplibs"))} {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (ForEach
                                                      iter_name: deplib
                                                      iter_words: [{($ VSub_Name "$dependency_libs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Case
                                                              to_match: {($ VSub_Name "$deplib")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [{(-L) (Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:path)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                )
                                                                              )
                                                                            }
                                                                          spids: [20075]
                                                                        )
                                                                      ]
                                                                      spids: [20075]
                                                                    )
                                                                  ]
                                                                  spids: [20071 20073 20080 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*") (.la)}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:dir)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) ($ VSub_Name "$deplib"))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(SQ <"s%/[^/]*$%%">)}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [20089 20106]
                                                                              )
                                                                            }
                                                                          spids: [20088]
                                                                        )
                                                                      ]
                                                                      spids: [20088]
                                                                    )
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ (X) 
                                                                              ($ VSub_Name "$dir")
                                                                            )
                                                                          } {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$deplib"))}
                                                                        )
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: (LhsName name:dir)
                                                                              op: Equal
                                                                              rhs: {(DQ (.))}
                                                                              spids: [20125]
                                                                            )
                                                                          ]
                                                                          spids: [20125]
                                                                        )
                                                                      ]
                                                                      op_id: Op_DAmp
                                                                    )
                                                                    (Case
                                                                      to_match: {($ VSub_Name "$dir")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "[") 
                                                                              (EscapedLiteralPart
                                                                                token: 
                                                                                  <Lit_EscapedChar 
"\\\\"
                                                                                  >
                                                                              ) (/) (Lit_Other "]") (Lit_Other "*")
                                                                            }
                                                                            {(Lit_Other "[") 
                                                                              (A-Za-z) (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) 
                                                                              (Lit_Other "]") (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: absdir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$dir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [20161]
                                                                                )
                                                                              ]
                                                                              spids: [20161]
                                                                            )
                                                                          ]
                                                                          spids: [20142 20159 20166 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: absdir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (AndOr
                                                                                                children: [
                                                                                                  (C 
                                                                                                    {
                                                                                                      (
cd
                                                                                                      )
                                                                                                    } {(DQ ($ VSub_Name "$dir"))}
                                                                                                  )
                                                                                                  (C 
                                                                                                    {
                                                                                                      (
pwd
                                                                                                      )
                                                                                                    }
                                                                                                  )
                                                                                                ]
                                                                                                op_id: 
Op_DAmp
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
20174
20184
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [20173]
                                                                                )
                                                                              ]
                                                                              spids: [20173]
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {(-z)} {(DQ ($ VSub_Name "$absdir"))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (SimpleCommand
                                                                                      words: [
                                                                                        {
                                                                                          ($ 
VSub_Name "$echo"
                                                                                          )
                                                                                        }
                                                                                        {
                                                                                          (DQ 
                                                                                            ($ 
VSub_Name "$modename"
                                                                                            ) (": warning: cannot determine absolute directory name of ") 
                                                                                            (EscapedLiteralPart
                                                                                              token: 
                                                                                                <
Lit_EscapedChar "\\`"
                                                                                                >
                                                                                            ) ($ VSub_Name "$dir") ("'")
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      redirects: [
                                                                                        (Redir
                                                                                          op_id: 
Redir_GreatAnd
                                                                                          fd: 1
                                                                                          arg_word: 
                                                                                            {(2)}
                                                                                          spids: [
20211
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
absdir
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$dir"
                                                                                                )
                                                                                              )
                                                                                            }
                                                                                          spids: [
20215
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [20215]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 20198]
                                                                                )
                                                                              ]
                                                                              spids: [-1 20221]
                                                                            )
                                                                          ]
                                                                          spids: [20169 20170 20224 -1]
                                                                        )
                                                                      ]
                                                                      spids: [20135 20139 20227]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (SimpleCommand
                                                                                  words: [
                                                                                    {(grep)}
                                                                                    {
                                                                                      (DQ 
                                                                                        (
"^installed=no"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                    {
                                                                                      ($ VSub_Name 
"$deplib"
                                                                                      )
                                                                                    }
                                                                                  ]
                                                                                  redirects: [
                                                                                    (Redir
                                                                                      op_id: 
Redir_Great
                                                                                      fd: -1
                                                                                      arg_word: 
                                                                                        {
                                                                                          (
/dev/null
                                                                                          )
                                                                                        }
                                                                                      spids: [20240]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: path
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$absdir"
                                                                                        ) (/) ($ VSub_Name "$objdir")
                                                                                      )
                                                                                    }
                                                                                  spids: [20248]
                                                                                )
                                                                              ]
                                                                              spids: [20248]
                                                                            )
                                                                          ]
                                                                          spids: [-1 20245]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (C {(eval)} 
                                                                          {(Lit_VarLike "libdir=") 
                                                                            (CommandSubPart
                                                                              command_list: 
                                                                                (CommandList
                                                                                  children: [
                                                                                    (C 
                                                                                      {
                                                                                        (${ 
VSub_Name SED
                                                                                        )
                                                                                      } {(-n)} {(-e)} {(SQ <"s/^libdir=\\(.*\\)$/\\1/p">)} {($ VSub_Name "$deplib")}
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              left_token: 
                                                                                <Left_Backtick "`">
                                                                              spids: [20262 20276]
                                                                            )
                                                                          }
                                                                        )
                                                                        (If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (Sentence
                                                                                  child: 
                                                                                    (C {(test)} {(-z)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$libdir"
                                                                                          )
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ";">
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (SimpleCommand
                                                                                  words: [
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    }
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$modename"
                                                                                        ) (": ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$deplib") 
                                                                                        (
"' is not a valid libtool archive"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  ]
                                                                                  redirects: [
                                                                                    (Redir
                                                                                      op_id: 
Redir_GreatAnd
                                                                                      fd: 1
                                                                                      arg_word: {(2)}
                                                                                      spids: [20303]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                                (C {(exit)} 
                                                                                  {
                                                                                    ($ VSub_Name 
"$EXIT_FAILURE"
                                                                                    )
                                                                                  }
                                                                                )
                                                                              ]
                                                                              spids: [-1 20290]
                                                                            )
                                                                          ]
                                                                          spids: [-1 20312]
                                                                        )
                                                                        (If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (Sentence
                                                                                  child: 
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$absdir"
                                                                                          )
                                                                                        )
                                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$libdir"))}
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ";">
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (SimpleCommand
                                                                                  words: [
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    }
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$modename"
                                                                                        ) (": warning: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$deplib") 
                                                                                        (
"' seems to be moved"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  ]
                                                                                  redirects: [
                                                                                    (Redir
                                                                                      op_id: 
Redir_GreatAnd
                                                                                      fd: 1
                                                                                      arg_word: {(2)}
                                                                                      spids: [20344]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              spids: [-1 20331]
                                                                            )
                                                                          ]
                                                                          spids: [-1 20348]
                                                                        )
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: path
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$absdir"
                                                                                    )
                                                                                  )
                                                                                }
                                                                              spids: [20351]
                                                                            )
                                                                          ]
                                                                          spids: [20351]
                                                                        )
                                                                      ]
                                                                      spids: [20256 20357]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:depdepl)
                                                                          op: Equal
                                                                          rhs: {(SQ )}
                                                                          spids: [20360]
                                                                        )
                                                                      ]
                                                                      spids: [20360]
                                                                    )
                                                                    (Case
                                                                      to_match: 
                                                                        {($ VSub_Name "$host")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-darwin) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (C {(eval)} 
                                                                              {
                                                                                (Lit_VarLike 
"deplibrary_names="
                                                                                ) 
                                                                                (CommandSubPart
                                                                                  command_list: 
                                                                                    (CommandList
                                                                                      children: [
                                                                                        (C 
                                                                                          {
                                                                                            (${ 
VSub_Name SED
                                                                                            )
                                                                                          } {(-n)} {(-e)} {(SQ <"s/^library_names=\\(.*\\)$/\\1/p">)} {($ VSub_Name "$deplib")}
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  left_token: 
                                                                                    <Left_Backtick 
"`"
                                                                                    >
                                                                                  spids: [20389 20403]
                                                                                )
                                                                              }
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {(-n)} {(DQ ($ VSub_Name "$deplibrary_names"))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (ForEach
                                                                                      iter_name: tmp
                                                                                      iter_words: [
                                                                                        {
                                                                                          ($ 
VSub_Name "$deplibrary_names"
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      do_arg_iter: 
False
                                                                                      body: 
                                                                                        (DoGroup
                                                                                          children: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
depdepl
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      ($ 
VSub_Name "$tmp"
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
20434
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
20434
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
20431
20438
                                                                                          ]
                                                                                        )
                                                                                      spids: [
20426
20429
                                                                                      ]
                                                                                    )
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (C 
                                                                                                  {
                                                                                                    (
test
                                                                                                    )
                                                                                                  } {(-f)} {(DQ ($ VSub_Name "$path") (/) ($ VSub_Name "$depdepl"))}
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
depdepl
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (DQ 
                                                                                                        ($ 
VSub_Name "$path"
                                                                                                        ) (/) ($ VSub_Name "$depdepl")
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
20458
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
20458
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
20455
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
20466
                                                                                      ]
                                                                                    )
                                                                                    (Case
                                                                                      to_match: 
                                                                                        {
                                                                                          (DQ (" ") 
                                                                                            ($ 
VSub_Name "$newlib_search_path"
                                                                                            ) (" ")
                                                                                          )
                                                                                        }
                                                                                      arms: [
                                                                                        (case_arm
                                                                                          pat_list: [
                                                                                            {
                                                                                              (
Lit_Other "*"
                                                                                              ) (DQ (" ") ($ VSub_Name "$path") (" ")) (Lit_Other "*")
                                                                                            }
                                                                                          ]
                                                                                          spids: [
20484
20491
20493
-1
                                                                                          ]
                                                                                        )
                                                                                        (case_arm
                                                                                          pat_list: [
                                                                                            {
                                                                                              (
Lit_Other "*"
                                                                                              )
                                                                                            }
                                                                                          ]
                                                                                          action: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
newlib_search_path
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (DQ 
                                                                                                        ($ 
VSub_Name "$newlib_search_path"
                                                                                                        ) (" ") ($ VSub_Name "$path")
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
20499
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
20499
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
20496
20497
20505
-1
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
20473
20481
20508
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 20418]
                                                                                )
                                                                              ]
                                                                              spids: [-1 20511]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: path
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(DQ )}
                                                                                  spids: [20514]
                                                                                )
                                                                              ]
                                                                              spids: [20514]
                                                                            )
                                                                          ]
                                                                          spids: [20370 20375 20519 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: path
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ (-L) 
                                                                                        ($ VSub_Name 
"$path"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [20526]
                                                                                )
                                                                              ]
                                                                              spids: [20526]
                                                                            )
                                                                          ]
                                                                          spids: [20522 20523 20533 -1]
                                                                        )
                                                                      ]
                                                                      spids: [20363 20367 20536]
                                                                    )
                                                                  ]
                                                                  spids: [20083 20085 20539 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(-l) (Lit_Other "*")}]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {($ VSub_Name "$host")}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") (-) 
                                                                              (Lit_Other "*") (-darwin) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (C {(eval)} 
                                                                              {
                                                                                (Lit_VarLike 
"tmp_libs="
                                                                                ) 
                                                                                (CommandSubPart
                                                                                  command_list: 
                                                                                    (CommandList
                                                                                      children: [
                                                                                        (Pipeline
                                                                                          children: [
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_Name "$echo"
                                                                                                )
                                                                                              } {(DQ (X) ($ VSub_Name "$deplib"))}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_Name "$Xsed"
                                                                                                )
                                                                                              } {(-e)} {(DQ ("s,^") (EscapedLiteralPart token:<Lit_EscapedChar "\\-">) ("l,,"))}
                                                                                            )
                                                                                          ]
                                                                                          negated: 
False
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  left_token: 
                                                                                    <Left_Backtick 
"`"
                                                                                    >
                                                                                  spids: [20569 20588]
                                                                                )
                                                                              }
                                                                            )
                                                                            (ForEach
                                                                              iter_name: tmp
                                                                              iter_words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$newlib_search_path"
                                                                                  )
                                                                                }
                                                                              ]
                                                                              do_arg_iter: False
                                                                              body: 
                                                                                (DoGroup
                                                                                  children: [
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (C 
                                                                                                  {
                                                                                                    (
test
                                                                                                    )
                                                                                                  } {(-f)} {(DQ ($ VSub_Name "$tmp") (/lib) ($ VSub_Name "$tmp_libs") (.dylib))}
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (C 
                                                                                              {
                                                                                                (
eval
                                                                                                )
                                                                                              } {(Lit_VarLike "depdepl=") (DQ ($ VSub_Name "$tmp") (/lib) ($ VSub_Name "$tmp_libs") (.dylib))}
                                                                                            )
                                                                                            (ControlFlow
                                                                                              token: 
                                                                                                <
ControlFlow_Break break
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
20619
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
20636
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [20601 20639]
                                                                                )
                                                                              spids: [20596 20599]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: path
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(DQ )}
                                                                                  spids: [20642]
                                                                                )
                                                                              ]
                                                                              spids: [20642]
                                                                            )
                                                                          ]
                                                                          spids: [20554 20559 20647 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (ControlFlow
                                                                              token: 
                                                                                <
ControlFlow_Continue continue
                                                                                >
                                                                            )
                                                                          ]
                                                                          spids: [20650 20651 20655 -1]
                                                                        )
                                                                      ]
                                                                      spids: [20547 20551 20658]
                                                                    )
                                                                  ]
                                                                  spids: [20542 20544 20661 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (ControlFlow
                                                                      token: 
                                                                        <ControlFlow_Continue 
continue
                                                                        >
                                                                    )
                                                                  ]
                                                                  spids: [20664 20665 20669 -1]
                                                                )
                                                              ]
                                                              spids: [20064 20068 20672]
                                                            )
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ (" ") ($ VSub_Name "$deplibs") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") ($ VSub_Name "$path") 
                                                                        (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [20686 20693 20695 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:deplibs)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$path") (" ") ($ VSub_Name "$deplibs")
                                                                              )
                                                                            }
                                                                          spids: [20701]
                                                                        )
                                                                      ]
                                                                      spids: [20701]
                                                                    )
                                                                  ]
                                                                  spids: [20698 20699 20708 -1]
                                                                )
                                                              ]
                                                              spids: [20675 20683 20711]
                                                            )
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ (" ") ($ VSub_Name "$deplibs") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$depdepl") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [20725 20732 20734 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:deplibs)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$depdepl"
                                                                                ) (" ") ($ VSub_Name "$deplibs")
                                                                              )
                                                                            }
                                                                          spids: [20740]
                                                                        )
                                                                      ]
                                                                      spids: [20740]
                                                                    )
                                                                  ]
                                                                  spids: [20737 20738 20747 -1]
                                                                )
                                                              ]
                                                              spids: [20714 20722 20750]
                                                            )
                                                          ]
                                                          spids: [20061 20753]
                                                        )
                                                      spids: [20057 20059]
                                                    )
                                                  ]
                                                  spids: [-1 20045]
                                                )
                                              ]
                                              spids: [-1 20756]
                                            )
                                          ]
                                          spids: [-1 19723]
                                        )
                                      ]
                                      spids: [-1 20762]
                                    )
                                  ]
                                  spids: [13641 20768]
                                )
                              spids: [13637 13639]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dependency_libs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$newdependency_libs"))}
                                  spids: [20774]
                                )
                              ]
                              spids: [20774]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} {(Lit_Other "=")} 
                                          {(dlpreopen)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_Name "$save_deplibs")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$deplib") (" ") 
                                                        ($ VSub_Name "$deplibs")
                                                      )
                                                    }
                                                  spids: [20812]
                                                )
                                              ]
                                              spids: [20812]
                                            )
                                          ]
                                          spids: [20809 20820]
                                        )
                                      spids: [20805 20807]
                                    )
                                  ]
                                  spids: [-1 20793]
                                )
                              ]
                              spids: [-1 20823]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(dlopen)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$pass"))} 
                                                  {(KW_Bang "!") (Lit_Other "=")} {(conv)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lib_search_path)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [20864]
                                                )
                                              ]
                                              spids: [20864]
                                            )
                                            (ForEach
                                              iter_name: dir
                                              iter_words: [{($ VSub_Name "$newlib_search_path")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Case
                                                      to_match: 
                                                        {(DQ ($ VSub_Name "$lib_search_path") (" "))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$dir") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [20889 20896 20898 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:lib_search_path)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name 
"$lib_search_path"
                                                                        ) (" ") ($ VSub_Name "$dir")
                                                                      )
                                                                    }
                                                                  spids: [20904]
                                                                )
                                                              ]
                                                              spids: [20904]
                                                            )
                                                          ]
                                                          spids: [20901 20902 20911 -1]
                                                        )
                                                      ]
                                                      spids: [20879 20886 20914]
                                                    )
                                                  ]
                                                  spids: [20876 20917]
                                                )
                                              spids: [20872 20874]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newlib_search_path)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [20920]
                                                )
                                              ]
                                              spids: [20920]
                                            )
                                          ]
                                          spids: [-1 20857]
                                        )
                                      ]
                                      spids: [-1 20923]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} 
                                                  {
                                                    (DQ ($ VSub_Name "$linkmode") (",") 
                                                      ($ VSub_Name "$pass")
                                                    )
                                                  } {(KW_Bang "!") (Lit_Other "=")} {(DQ ("prog,link"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:vars)
                                                  op: Equal
                                                  rhs: {(DQ (deplibs))}
                                                  spids: [20948]
                                                )
                                              ]
                                              spids: [20948]
                                            )
                                          ]
                                          spids: [-1 20945]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:vars)
                                              op: Equal
                                              rhs: {(DQ ("compile_deplibs finalize_deplibs"))}
                                              spids: [20957]
                                            )
                                          ]
                                          spids: [20957]
                                        )
                                      ]
                                      spids: [20954 20963]
                                    )
                                    (ForEach
                                      iter_name: var
                                      iter_words: [{($ VSub_Name "$vars")} {(dependency_libs)}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "tmp_libs=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$var") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                )
                                              }
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:new_libs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [20993]
                                                )
                                              ]
                                              spids: [20993]
                                            )
                                            (ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_Name "$tmp_libs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Case
                                                      to_match: {($ VSub_Name "$deplib")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-L) (Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:new_libs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplib") 
                                                                        (" ") ($ VSub_Name "$new_libs")
                                                                      )
                                                                    }
                                                                  spids: [21043]
                                                                )
                                                              ]
                                                              spids: [21043]
                                                            )
                                                          ]
                                                          spids: [21039 21041 21050 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(-R) (Lit_Other "*")}]
                                                          spids: [21053 21055 21057 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ (" ") 
                                                                    ($ VSub_Name "$specialdeplibs") (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$deplib") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: new_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                ) (" ") ($ VSub_Name "$new_libs")
                                                                              )
                                                                            }
                                                                          spids: [21140]
                                                                        )
                                                                      ]
                                                                      spids: [21140]
                                                                    )
                                                                  ]
                                                                  spids: [21131 21138 21147 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ (" ") 
                                                                            ($ VSub_Name "$new_libs") (" ")
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") 
                                                                              (DQ (" ") 
                                                                                ($ VSub_Name 
"$deplib"
                                                                                ) (" ")
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          spids: [21165 21172 21174 -1]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Other "*")}]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: new_libs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$deplib"
                                                                                        ) (" ") ($ VSub_Name "$new_libs")
                                                                                      )
                                                                                    }
                                                                                  spids: [21180]
                                                                                )
                                                                              ]
                                                                              spids: [21180]
                                                                            )
                                                                          ]
                                                                          spids: [21177 21178 21187 -1]
                                                                        )
                                                                      ]
                                                                      spids: [21154 21162 21190]
                                                                    )
                                                                  ]
                                                                  spids: [21150 21151 21193 -1]
                                                                )
                                                              ]
                                                              spids: [21120 21128 21196]
                                                            )
                                                          ]
                                                          spids: [21060 21061 21199 -1]
                                                        )
                                                      ]
                                                      spids: [21032 21036 21202]
                                                    )
                                                  ]
                                                  spids: [21005 21205]
                                                )
                                              spids: [21001 21003]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tmp_libs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [21208]
                                                )
                                              ]
                                              spids: [21208]
                                            )
                                            (ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_Name "$new_libs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Case
                                                      to_match: {($ VSub_Name "$deplib")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-L) (Lit_Other "*")}]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ (" ") ($ VSub_Name "$tmp_libs") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$deplib") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [21246 21253 21255 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: tmp_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$tmp_libs"
                                                                                ) (" ") ($ VSub_Name "$deplib")
                                                                              )
                                                                            }
                                                                          spids: [21261]
                                                                        )
                                                                      ]
                                                                      spids: [21261]
                                                                    )
                                                                  ]
                                                                  spids: [21258 21259 21268 -1]
                                                                )
                                                              ]
                                                              spids: [21235 21243 21271]
                                                            )
                                                          ]
                                                          spids: [21230 21232 21274 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:tmp_libs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$tmp_libs") 
                                                                        (" ") ($ VSub_Name "$deplib")
                                                                      )
                                                                    }
                                                                  spids: [21280]
                                                                )
                                                              ]
                                                              spids: [21280]
                                                            )
                                                          ]
                                                          spids: [21277 21278 21287 -1]
                                                        )
                                                      ]
                                                      spids: [21223 21227 21290]
                                                    )
                                                  ]
                                                  spids: [21220 21293]
                                                )
                                              spids: [21216 21218]
                                            )
                                            (C {(eval)} 
                                              {($ VSub_Name "$var") (Lit_Other "=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$tmp_libs") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                          ]
                                          spids: [20977 21305]
                                        )
                                      spids: [20971 20975]
                                    )
                                  ]
                                  spids: [-1 20840]
                                )
                              ]
                              spids: [-1 21311]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:tmp_libs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [21322]
                                )
                              ]
                              spids: [21322]
                            )
                            (ForEach
                              iter_name: i
                              iter_words: [{($ VSub_Name "$dependency_libs")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: 
                                        {
                                          (DQ (" ") ($ VSub_Name "$predeps") (" ") 
                                            ($ VSub_Name "$postdeps") (" ") ($ VSub_Name "$compiler_lib_search_path") (" ")
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$i") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:i)
                                                  op: Equal
                                                  rhs: {(DQ )}
                                                  spids: [21363]
                                                )
                                              ]
                                              spids: [21363]
                                            )
                                          ]
                                          spids: [21353 21360 21368 -1]
                                        )
                                      ]
                                      spids: [21338 21350 21371]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$i"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tmp_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$tmp_libs") (" ") 
                                                        ($ VSub_Name "$i")
                                                      )
                                                    }
                                                  spids: [21389]
                                                )
                                              ]
                                              spids: [21389]
                                            )
                                          ]
                                          spids: [-1 21386]
                                        )
                                      ]
                                      spids: [-1 21397]
                                    )
                                  ]
                                  spids: [21335 21400]
                                )
                              spids: [21330 21333]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dependency_libs)
                                  op: Equal
                                  rhs: {($ VSub_Name "$tmp_libs")}
                                  spids: [21403]
                                )
                              ]
                              spids: [21403]
                            )
                          ]
                          spids: [13484 21407]
                        )
                      spids: [13480 13482]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$linkmode"))} {(Lit_Other "=")} {(prog)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlfiles)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$newdlfiles"))}
                                  spids: [21429]
                                )
                              ]
                              spids: [21429]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlprefiles)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$newdlprefiles"))}
                                  spids: [21435]
                                )
                              ]
                              spids: [21435]
                            )
                          ]
                          spids: [-1 21426]
                        )
                      ]
                      spids: [-1 21441]
                    )
                    (Case
                      to_match: {($ VSub_Name "$linkmode")}
                      arms: [
                        (case_arm
                          pat_list: [{(oldlib)}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$deplibs"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-l' and ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-L' are ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21481]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21467]
                                )
                              ]
                              spids: [-1 21485]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {
                                                (DQ ($ VSub_Name "$dlfiles") 
                                                  ($ VSub_Name "$dlprefiles")
                                                )
                                              }
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$dlself"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-dlopen' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21526]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21514]
                                )
                              ]
                              spids: [-1 21530]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$rpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-rpath' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21557]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21545]
                                )
                              ]
                              spids: [-1 21561]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$xrpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-R' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21588]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21576]
                                )
                              ]
                              spids: [-1 21592]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$vinfo"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-version-info/-version-number' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21619]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21607]
                                )
                              ]
                              spids: [-1 21623]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$release"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-release' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21650]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21638]
                                )
                              ]
                              spids: [-1 21654]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$export_symbols"))})
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_Name "$export_symbols_regex"))}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-export-symbols' is ignored for archives")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [21691]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 21679]
                                )
                              ]
                              spids: [-1 21695]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:build_libtool_libs)
                                  op: Equal
                                  rhs: {(no)}
                                  spids: [21703]
                                )
                              ]
                              spids: [21703]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:oldlibs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$output"))}
                                  spids: [21707]
                                )
                              ]
                              spids: [21707]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:objs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$objs") ($ VSub_Name "$old_deplibs"))}
                                  spids: [21713]
                                )
                              ]
                              spids: [21713]
                            )
                          ]
                          spids: [21452 21453 21720 -1]
                        )
                        (case_arm
                          pat_list: [{(lib)}]
                          action: [
                            (Case
                              to_match: {($ VSub_Name "$outputname")}
                              arms: [
                                (case_arm
                                  pat_list: [{(lib) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:name)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$outputname"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/\\.la$//">)} {(-e)} {(SQ <"s/^lib//">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [21745 21768]
                                              )
                                            }
                                          spids: [21744]
                                        )
                                      ]
                                      spids: [21744]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "shared_ext=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$shrext_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "libname=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                  ]
                                  spids: [21739 21741 21787 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$module"))} 
                                                  {(Lit_Other "=")} {(no)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": libtool library ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ($ VSub_Name "$output") ("' must begin with ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                                    ("lib'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [21822]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {(DQ ($ VSub_Name "$help"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [21832]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [-1 21807]
                                        )
                                      ]
                                      spids: [-1 21841]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$need_lib_prefix"))} 
                                                  {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:name)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) 
                                                                        ($ VSub_Name "$outputname")
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s/\\.la$//">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [21866 21883]
                                                      )
                                                    }
                                                  spids: [21865]
                                                )
                                              ]
                                              spids: [21865]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike "shared_ext=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$shrext_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike "libname=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                          ]
                                          spids: [-1 21858]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:libname)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {
                                                                  (DQ (X) ($ VSub_Name "$outputname"))
                                                                }
                                                              )
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {(SQ <"s/\\.la$//">)}
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [21906 21923]
                                                  )
                                                }
                                              spids: [21905]
                                            )
                                          ]
                                          spids: [21905]
                                        )
                                      ]
                                      spids: [21902 21926]
                                    )
                                  ]
                                  spids: [21790 21791 21929 -1]
                                )
                              ]
                              spids: [21732 21736 21932]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$objs"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$deplibs_check_method"))} 
                                                  {(KW_Bang "!") (Lit_Other "=")} {(pass_all)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": cannot build libtool library ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$output") 
                                                    ("' from non-libtool objects on this host:") ($ VSub_Name "$objs")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 2
                                                  arg_word: {(1)}
                                                  spids: [21978]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [-1 21964]
                                        )
                                      ]
                                      else_action: [
                                        (C {($ VSub_Name "$echo")})
                                        (C {($ VSub_Name "$echo")} 
                                          {
                                            (DQ ("*** Warning: Linking the shared library ") 
                                              ($ VSub_Name "$output") (" against the non-libtool")
                                            )
                                          }
                                        )
                                        (C {($ VSub_Name "$echo")} 
                                          {
                                            (DQ ("*** objects ") ($ VSub_Name "$objs") 
                                              (" is not portable!")
                                            )
                                          }
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:libobjs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$libobjs") (" ") 
                                                    ($ VSub_Name "$objs")
                                                  )
                                                }
                                              spids: [22011]
                                            )
                                          ]
                                          spids: [22011]
                                        )
                                      ]
                                      spids: [21987 22019]
                                    )
                                  ]
                                  spids: [-1 21947]
                                )
                              ]
                              spids: [-1 22022]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$dlself"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-dlopen self' is ignored for libtool libraries")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [22052]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 22040]
                                )
                              ]
                              spids: [-1 22056]
                            )
                            (C {(set)} {(dummy)} {($ VSub_Name "$rpath")})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-gt)} {(2)})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") 
                                            (": warning: ignoring multiple ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-rpath's for a libtool library")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [22092]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 22080]
                                )
                              ]
                              spids: [-1 22096]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:install_libdir)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$2"))}
                                  spids: [22099]
                                )
                              ]
                              spids: [22099]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:oldlibs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [22106]
                                )
                              ]
                              spids: [22106]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$rpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:oldlibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$output_objdir") (/) 
                                                        ($ VSub_Name "$libname") (.) ($ VSub_Name "$libext") (" ") ($ VSub_Name "$oldlibs")
                                                      )
                                                    }
                                                  spids: [22155]
                                                )
                                              ]
                                              spids: [22155]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:build_libtool_libs)
                                                  op: Equal
                                                  rhs: {(convenience)}
                                                  spids: [22167]
                                                )
                                              ]
                                              spids: [22167]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:build_old_libs)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [22171]
                                                )
                                              ]
                                              spids: [22171]
                                            )
                                          ]
                                          spids: [-1 22136]
                                        )
                                      ]
                                      spids: [-1 22175]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$vinfo"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": warning: ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("-version-info/-version-number' is ignored for convenience libraries")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [22202]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 22190]
                                        )
                                      ]
                                      spids: [-1 22206]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$release"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": warning: ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("-release' is ignored for convenience libraries")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [22233]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 22221]
                                        )
                                      ]
                                      spids: [-1 22237]
                                    )
                                  ]
                                  spids: [-1 22120]
                                )
                              ]
                              else_action: [
                                (Sentence
                                  child: 
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:save_ifs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$IFS"))}
                                          spids: [22248]
                                        )
                                      ]
                                      spids: [22248]
                                    )
                                  terminator: <Op_Semi ";">
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:IFS)
                                      op: Equal
                                      rhs: {(SQ <":">)}
                                      spids: [22254]
                                    )
                                  ]
                                  spids: [22254]
                                )
                                (C {(set)} {(dummy)} {($ VSub_Name "$vinfo")} {(0)} {(0)} {(0)})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:IFS)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                      spids: [22273]
                                    )
                                  ]
                                  spids: [22273]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: (C {(test)} {(-n)} {(DQ ($ VSub_Number "$8"))})
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") 
                                                (": too many parameters to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-version-info'")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22303]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22313]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [-1 22291]
                                    )
                                  ]
                                  spids: [-1 22322]
                                )
                                (Case
                                  to_match: {($ VSub_Name "$vinfo_number")}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(yes)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:number_major)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$2"))}
                                              spids: [22350]
                                            )
                                          ]
                                          spids: [22350]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:number_minor)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$3"))}
                                              spids: [22356]
                                            )
                                          ]
                                          spids: [22356]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:number_revision)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$4"))}
                                              spids: [22362]
                                            )
                                          ]
                                          spids: [22362]
                                        )
                                        (Case
                                          to_match: {($ VSub_Name "$version_type")}
                                          arms: [
                                            (case_arm
                                              pat_list: [{(darwin)} {(linux)} {(osf)} {(windows)}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:current)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} 
                                                                    {($ VSub_Name "$number_major")} {(Lit_Other "+")} {($ VSub_Name "$number_minor")}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [22414 22422]
                                                          )
                                                        }
                                                      spids: [22413]
                                                    )
                                                  ]
                                                  spids: [22413]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:age)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_minor"))}
                                                      spids: [22425]
                                                    )
                                                  ]
                                                  spids: [22425]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:revision)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_revision"))}
                                                      spids: [22431]
                                                    )
                                                  ]
                                                  spids: [22431]
                                                )
                                              ]
                                              spids: [22403 22410 22437 -1]
                                            )
                                            (case_arm
                                              pat_list: [{(freebsd-aout)} {(freebsd-elf)} {(sunos)}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:current)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_major"))}
                                                      spids: [22448]
                                                    )
                                                  ]
                                                  spids: [22448]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:revision)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_minor"))}
                                                      spids: [22454]
                                                    )
                                                  ]
                                                  spids: [22454]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:age)
                                                      op: Equal
                                                      rhs: {(DQ (0))}
                                                      spids: [22460]
                                                    )
                                                  ]
                                                  spids: [22460]
                                                )
                                              ]
                                              spids: [22440 22445 22466 -1]
                                            )
                                            (case_arm
                                              pat_list: [{(irix)} {(nonstopux)}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:current)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} 
                                                                    {($ VSub_Name "$number_major")} {(Lit_Other "+")} {($ VSub_Name "$number_minor")} {(-)} {(1)}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [22476 22488]
                                                          )
                                                        }
                                                      spids: [22475]
                                                    )
                                                  ]
                                                  spids: [22475]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:age)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_minor"))}
                                                      spids: [22491]
                                                    )
                                                  ]
                                                  spids: [22491]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:revision)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$number_minor"))}
                                                      spids: [22497]
                                                    )
                                                  ]
                                                  spids: [22497]
                                                )
                                              ]
                                              spids: [22469 22472 22503 -1]
                                            )
                                          ]
                                          spids: [22396 22400 22506]
                                        )
                                      ]
                                      spids: [22346 22347 22509 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(no)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:current)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$2"))}
                                              spids: [22516]
                                            )
                                          ]
                                          spids: [22516]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:revision)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$3"))}
                                              spids: [22522]
                                            )
                                          ]
                                          spids: [22522]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:age)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$4"))}
                                              spids: [22528]
                                            )
                                          ]
                                          spids: [22528]
                                        )
                                      ]
                                      spids: [22512 22513 22534 -1]
                                    )
                                  ]
                                  spids: [22339 22343 22537]
                                )
                                (Case
                                  to_match: {($ VSub_Name "$current")}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(0)}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]")}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                      ]
                                      spids: [22552 22603 22605 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": CURRENT ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$current") ("' must be a nonnegative integer")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22622]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$vinfo") ("' is not valid version information")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22636]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [22608 22609 22645 -1]
                                    )
                                  ]
                                  spids: [22545 22549 22648]
                                )
                                (Case
                                  to_match: {($ VSub_Name "$revision")}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(0)}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]")}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                      ]
                                      spids: [22659 22710 22712 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": REVISION ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$revision") ("' must be a nonnegative integer")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22729]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$vinfo") ("' is not valid version information")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22743]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [22715 22716 22752 -1]
                                    )
                                  ]
                                  spids: [22652 22656 22755]
                                )
                                (Case
                                  to_match: {($ VSub_Name "$age")}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(0)}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]")}
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]")
                                        }
                                        {(Lit_Other "[") (1-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "[") (0-9) 
                                          (Lit_Other "]")
                                        }
                                      ]
                                      spids: [22766 22817 22819 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": AGE ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$age") ("' must be a nonnegative integer")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22836]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$vinfo") ("' is not valid version information")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22850]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [22822 22823 22859 -1]
                                    )
                                  ]
                                  spids: [22759 22763 22862]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(test)} {(DQ ($ VSub_Name "$age"))} {(-gt)} 
                                              {(DQ ($ VSub_Name "$current"))}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": AGE ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$age") ("' is greater than the current interface number ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$current") ("'")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22897]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$vinfo") ("' is not valid version information")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [22911]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [-1 22881]
                                    )
                                  ]
                                  spids: [-1 22920]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:major)
                                      op: Equal
                                      rhs: {(SQ )}
                                      spids: [22928]
                                    )
                                  ]
                                  spids: [22928]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:versuffix)
                                      op: Equal
                                      rhs: {(SQ )}
                                      spids: [22931]
                                    )
                                  ]
                                  spids: [22931]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:verstring)
                                      op: Equal
                                      rhs: {(SQ )}
                                      spids: [22934]
                                    )
                                  ]
                                  spids: [22934]
                                )
                                (Case
                                  to_match: {($ VSub_Name "$version_type")}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(none)}]
                                      spids: [22944 22945 22947 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(darwin)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: 
                                                {(.) 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} {(-)} 
                                                            {($ VSub_Name "$age")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [22965 22973]
                                                  )
                                                }
                                              spids: [22963]
                                            )
                                          ]
                                          spids: [22963]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$major") (.) ($ VSub_Name "$age") 
                                                    (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [22976]
                                            )
                                          ]
                                          spids: [22976]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:minor_current)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} 
                                                            {(Lit_Other "+")} {(1)}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [22991 22999]
                                                  )
                                                }
                                              spids: [22990]
                                            )
                                          ]
                                          spids: [22990]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (${ VSub_Name wl) ("-compatibility_version ") 
                                                    (${ VSub_Name wl) ($ VSub_Name "$minor_current") (" ") (${ VSub_Name wl) ("-current_version ") (${ VSub_Name wl) 
                                                    ($ VSub_Name "$minor_current") (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23002]
                                            )
                                          ]
                                          spids: [23002]
                                        )
                                      ]
                                      spids: [22951 22952 23026 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(freebsd-aout)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(DQ (.) ($ VSub_Name "$current"))}
                                              spids: [23034]
                                            )
                                          ]
                                          spids: [23034]
                                        )
                                        (Sentence
                                          child: 
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:versuffix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ (.) ($ VSub_Name "$current") (.) 
                                                        ($ VSub_Name "$revision")
                                                      )
                                                    }
                                                  spids: [23041]
                                                )
                                              ]
                                              spids: [23041]
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      spids: [23030 23031 23051 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(freebsd-elf)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(DQ (.) ($ VSub_Name "$current"))}
                                              spids: [23059]
                                            )
                                          ]
                                          spids: [23059]
                                        )
                                        (Sentence
                                          child: 
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:versuffix)
                                                  op: Equal
                                                  rhs: {(DQ (.) ($ VSub_Name "$current"))}
                                                  spids: [23066]
                                                )
                                              ]
                                              spids: [23066]
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      spids: [23055 23056 23074 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(irix)} {(nonstopux)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} {(-)} 
                                                            {($ VSub_Name "$age")} {(Lit_Other "+")} {(1)}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [23087 23099]
                                                  )
                                                }
                                              spids: [23086]
                                            )
                                          ]
                                          spids: [23086]
                                        )
                                        (Case
                                          to_match: {($ VSub_Name "$version_type")}
                                          arms: [
                                            (case_arm
                                              pat_list: [{(nonstopux)}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring_prefix)
                                                      op: Equal
                                                      rhs: {(nonstopux)}
                                                      spids: [23113]
                                                    )
                                                  ]
                                                  spids: [23113]
                                                )
                                              ]
                                              spids: [23110 23111 23116 -1]
                                            )
                                            (case_arm
                                              pat_list: [{(Lit_Other "*")}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring_prefix)
                                                      op: Equal
                                                      rhs: {(sgi)}
                                                      spids: [23122]
                                                    )
                                                  ]
                                                  spids: [23122]
                                                )
                                              ]
                                              spids: [23119 23120 23125 -1]
                                            )
                                          ]
                                          spids: [23103 23107 23128]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$verstring_prefix") 
                                                    ($ VSub_Name "$major") (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23131]
                                            )
                                          ]
                                          spids: [23131]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:loop)
                                              op: Equal
                                              rhs: {($ VSub_Name "$revision")}
                                              spids: [23145]
                                            )
                                          ]
                                          spids: [23145]
                                        )
                                        (While
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$loop"))} {(-ne)} {(0)})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          body: 
                                            (DoGroup
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:iface)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} 
                                                                    {($ VSub_Name "$revision")} {(-)} {($ VSub_Name "$loop")}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [23166 23174]
                                                          )
                                                        }
                                                      spids: [23165]
                                                    )
                                                  ]
                                                  spids: [23165]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:loop)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} {($ VSub_Name "$loop")} 
                                                                    {(-)} {(1)}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [23178 23186]
                                                          )
                                                        }
                                                      spids: [23177]
                                                    )
                                                  ]
                                                  spids: [23177]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$verstring_prefix") 
                                                            ($ VSub_Name "$major") (.) ($ VSub_Name "$iface") (":") ($ VSub_Name "$verstring")
                                                          )
                                                        }
                                                      spids: [23189]
                                                    )
                                                  ]
                                                  spids: [23189]
                                                )
                                              ]
                                              spids: [23162 23200]
                                            )
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(.) ($ VSub_Name "$major")}
                                              spids: [23208]
                                            )
                                          ]
                                          spids: [23208]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$major") (.) 
                                                    ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23213]
                                            )
                                          ]
                                          spids: [23213]
                                        )
                                      ]
                                      spids: [23078 23083 23221 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(linux)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: 
                                                {(.) 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} {(-)} 
                                                            {($ VSub_Name "$age")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [23231 23239]
                                                  )
                                                }
                                              spids: [23229]
                                            )
                                          ]
                                          spids: [23229]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$major") (.) ($ VSub_Name "$age") 
                                                    (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23242]
                                            )
                                          ]
                                          spids: [23242]
                                        )
                                      ]
                                      spids: [23225 23226 23252 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(osf)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: 
                                                {(.) 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} {(-)} 
                                                            {($ VSub_Name "$age")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [23262 23270]
                                                  )
                                                }
                                              spids: [23260]
                                            )
                                          ]
                                          spids: [23260]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (.) ($ VSub_Name "$current") (.) 
                                                    ($ VSub_Name "$age") (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23273]
                                            )
                                          ]
                                          spids: [23273]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$current") (.) ($ VSub_Name "$age") 
                                                    (.) ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23284]
                                            )
                                          ]
                                          spids: [23284]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:loop)
                                              op: Equal
                                              rhs: {($ VSub_Name "$age")}
                                              spids: [23299]
                                            )
                                          ]
                                          spids: [23299]
                                        )
                                        (While
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$loop"))} {(-ne)} {(0)})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          body: 
                                            (DoGroup
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:iface)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} 
                                                                    {($ VSub_Name "$current")} {(-)} {($ VSub_Name "$loop")}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [23320 23328]
                                                          )
                                                        }
                                                      spids: [23319]
                                                    )
                                                  ]
                                                  spids: [23319]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:loop)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} {($ VSub_Name "$loop")} 
                                                                    {(-)} {(1)}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [23332 23340]
                                                          )
                                                        }
                                                      spids: [23331]
                                                    )
                                                  ]
                                                  spids: [23331]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$verstring") (":") 
                                                            (${ VSub_Name iface) (.0)
                                                          )
                                                        }
                                                      spids: [23343]
                                                    )
                                                  ]
                                                  spids: [23343]
                                                )
                                              ]
                                              spids: [23316 23354]
                                            )
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$verstring") (":") 
                                                    (${ VSub_Name current) (.0)
                                                  )
                                                }
                                              spids: [23362]
                                            )
                                          ]
                                          spids: [23362]
                                        )
                                      ]
                                      spids: [23256 23257 23373 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(sunos)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(DQ (.) ($ VSub_Name "$current"))}
                                              spids: [23381]
                                            )
                                          ]
                                          spids: [23381]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (.) ($ VSub_Name "$current") (.) 
                                                    ($ VSub_Name "$revision")
                                                  )
                                                }
                                              spids: [23388]
                                            )
                                          ]
                                          spids: [23388]
                                        )
                                      ]
                                      spids: [23377 23378 23397 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(windows)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(expr)} {($ VSub_Name "$current")} {(-)} 
                                                            {($ VSub_Name "$age")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [23414 23422]
                                                  )
                                                }
                                              spids: [23413]
                                            )
                                          ]
                                          spids: [23413]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: {(DQ (-) ($ VSub_Name "$major"))}
                                              spids: [23425]
                                            )
                                          ]
                                          spids: [23425]
                                        )
                                      ]
                                      spids: [23401 23402 23432 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") 
                                                (": unknown library version type ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$version_type") ("'")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [23450]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ("Fatal configuration error.  See the ") 
                                                ($ VSub_Name "$PACKAGE") (" docs for more information.")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [23462]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [23436 23437 23471 -1]
                                    )
                                  ]
                                  spids: [22937 22941 23474]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$vinfo"))})
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$release"))})
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [23506]
                                            )
                                          ]
                                          spids: [23506]
                                        )
                                        (Case
                                          to_match: {($ VSub_Name "$version_type")}
                                          arms: [
                                            (case_arm
                                              pat_list: [{(darwin)}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring)
                                                      op: Equal
                                                      rhs: {(SQ )}
                                                      spids: [23528]
                                                    )
                                                  ]
                                                  spids: [23528]
                                                )
                                              ]
                                              spids: [23516 23517 23531 -1]
                                            )
                                            (case_arm
                                              pat_list: [{(Lit_Other "*")}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:verstring)
                                                      op: Equal
                                                      rhs: {(DQ (0.0))}
                                                      spids: [23538]
                                                    )
                                                  ]
                                                  spids: [23538]
                                                )
                                              ]
                                              spids: [23534 23535 23544 -1]
                                            )
                                          ]
                                          spids: [23509 23513 23547]
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C {(test)} {(DQ ($ VSub_Name "$need_version"))} 
                                                      {(Lit_Other "=")} {(no)}
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:versuffix)
                                                      op: Equal
                                                      rhs: {(SQ )}
                                                      spids: [23566]
                                                    )
                                                  ]
                                                  spids: [23566]
                                                )
                                              ]
                                              spids: [-1 23563]
                                            )
                                          ]
                                          else_action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:versuffix)
                                                  op: Equal
                                                  rhs: {(DQ (.0.0))}
                                                  spids: [23572]
                                                )
                                              ]
                                              spids: [23572]
                                            )
                                          ]
                                          spids: [23569 23578]
                                        )
                                      ]
                                      spids: [-1 23503]
                                    )
                                  ]
                                  spids: [-1 23581]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (AndOr
                                              children: [
                                                (C {(test)} {(DQ ($ VSub_Name "$avoid_version"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                                (C {(test)} {(DQ ($ VSub_Name "$need_version"))} 
                                                  {(Lit_Other "=")} {(no)}
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:major)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [23617]
                                            )
                                          ]
                                          spids: [23617]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:versuffix)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [23620]
                                            )
                                          ]
                                          spids: [23620]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verstring)
                                              op: Equal
                                              rhs: {(DQ )}
                                              spids: [23623]
                                            )
                                          ]
                                          spids: [23623]
                                        )
                                      ]
                                      spids: [-1 23614]
                                    )
                                  ]
                                  spids: [-1 23628]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(test)} {(DQ ($ VSub_Name "$allow_undefined"))} 
                                              {(Lit_Other "=")} {(yes)}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C {(test)} 
                                                      {(DQ ($ VSub_Name "$allow_undefined_flag"))} {(Lit_Other "=")} {(unsupported)}
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (SimpleCommand
                                                  words: [
                                                    {($ VSub_Name "$echo")}
                                                    {
                                                      (DQ ($ VSub_Name "$modename") 
                                                        (
": warning: undefined symbols not allowed in "
                                                        ) ($ VSub_Name "$host") (" shared libraries")
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 1
                                                      arg_word: {(2)}
                                                      spids: [23677]
                                                    )
                                                  ]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:build_libtool_libs)
                                                      op: Equal
                                                      rhs: {(no)}
                                                      spids: [23681]
                                                    )
                                                  ]
                                                  spids: [23681]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:build_old_libs)
                                                      op: Equal
                                                      rhs: {(yes)}
                                                      spids: [23685]
                                                    )
                                                  ]
                                                  spids: [23685]
                                                )
                                              ]
                                              spids: [-1 23665]
                                            )
                                          ]
                                          spids: [-1 23689]
                                        )
                                      ]
                                      spids: [-1 23649]
                                    )
                                  ]
                                  else_action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:allow_undefined_flag)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$no_undefined_flag"))}
                                          spids: [23699]
                                        )
                                      ]
                                      spids: [23699]
                                    )
                                  ]
                                  spids: [23692 23705]
                                )
                              ]
                              spids: [22240 23708]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(relink)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:removelist)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [23737]
                                        )
                                      ]
                                      spids: [23737]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:tempremovelist)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {($ VSub_Name "$echo")} 
                                                        {(DQ ($ VSub_Name "$output_objdir") ("/*"))}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [23741 23748]
                                              )
                                            }
                                          spids: [23740]
                                        )
                                      ]
                                      spids: [23740]
                                    )
                                    (ForEach
                                      iter_name: p
                                      iter_words: [{($ VSub_Name "$tempremovelist")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Case
                                              to_match: {($ VSub_Name "$p")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (.) ($ VSub_Name "$objext")}
                                                  ]
                                                  spids: [23770 23773 23776 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {($ VSub_Name "$output_objdir") (/) 
                                                      ($ VSub_Name "$outputname")
                                                    }
                                                    {($ VSub_Name "$output_objdir") (/) 
                                                      ($ VSub_Name "$libname") (.) (Lit_Other "*")
                                                    }
                                                    {($ VSub_Name "$output_objdir") (/) 
                                                      (${ VSub_Name libname) (${ VSub_Name release) (.) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ (X) 
                                                                      ($ VSub_Name 
"$precious_files_regex"
                                                                      )
                                                                    )
                                                                  } {(KW_Bang "!") (Lit_Other "=")} {(DQ (X))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Pipeline
                                                                      children: [
                                                                        (C {(echo)} 
                                                                          {($ VSub_Name "$p")}
                                                                        )
                                                                        (SimpleCommand
                                                                          words: [
                                                                            {($ VSub_Name "$EGREP")}
                                                                            {(-e)}
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$precious_files_regex"
                                                                                )
                                                                              )
                                                                            }
                                                                          ]
                                                                          redirects: [
                                                                            (Redir
                                                                              op_id: Redir_Great
                                                                              fd: -1
                                                                              arg_word: {(/dev/null)}
                                                                              spids: [23842]
                                                                            )
                                                                            (Redir
                                                                              op_id: Redir_GreatAnd
                                                                              fd: 2
                                                                              arg_word: {(1)}
                                                                              spids: [23845]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                      negated: False
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (ControlFlow
                                                                      token: 
                                                                        <ControlFlow_Continue 
continue
                                                                        >
                                                                    )
                                                                  ]
                                                                  spids: [-1 23849]
                                                                )
                                                              ]
                                                              spids: [-1 23855]
                                                            )
                                                          ]
                                                          spids: [-1 23823]
                                                        )
                                                      ]
                                                      spids: [-1 23858]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:removelist)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$removelist") (" ") 
                                                                ($ VSub_Name "$p")
                                                              )
                                                            }
                                                          spids: [23861]
                                                        )
                                                      ]
                                                      spids: [23861]
                                                    )
                                                  ]
                                                  spids: [23779 23803 23869 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  spids: [23872 23873 23875 -1]
                                                )
                                              ]
                                              spids: [23763 23767 23878]
                                            )
                                          ]
                                          spids: [23760 23881]
                                        )
                                      spids: [23756 23758]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$removelist"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ (${ VSub_Name rm) ("r ") 
                                                  ($ VSub_Name "$removelist")
                                                )
                                              }
                                            )
                                            (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} 
                                              {($ VSub_Name "$removelist")}
                                            )
                                          ]
                                          spids: [-1 23895]
                                        )
                                      ]
                                      spids: [-1 23919]
                                    )
                                  ]
                                  spids: [-1 23726]
                                )
                              ]
                              spids: [-1 23922]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} 
                                              {(Lit_Other "=")} {(yes)}
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(convenience)}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldlibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$oldlibs") (" ") 
                                                ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$libname") (.) ($ VSub_Name "$libext")
                                              )
                                            }
                                          spids: [23960]
                                        )
                                      ]
                                      spids: [23960]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: 
                                            {(DQ ($ VSub_Name "$objs") (" ")) 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$libobjs"))}
                                                          )
                                                          (C {($ VSub_Name "$SP2NL")})
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"/\\.">) (${ VSub_Name libext) 
                                                              (SQ <"$/d">)
                                                            } {(-e)} {(DQ ($ VSub_Name "$lo2o"))}
                                                          )
                                                          (C {($ VSub_Name "$NL2SP")})
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [23982 24019]
                                              )
                                            }
                                          spids: [23977]
                                        )
                                      ]
                                      spids: [23977]
                                    )
                                  ]
                                  spids: [-1 23957]
                                )
                              ]
                              spids: [-1 24022]
                            )
                            (ForEach
                              iter_name: path
                              iter_words: [{($ VSub_Name "$notinst_path")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lib_search_path)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ ($ VSub_Name "$lib_search_path") 
                                                                (" ")
                                                              )
                                                            }
                                                          )
                                                          (C {(${ VSub_Name SED)} {(-e)} 
                                                            {
                                                              (DQ ("s% ") ($ VSub_Name "$path") 
                                                                (" % %g")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [24043 24064]
                                              )
                                            }
                                          spids: [24042]
                                        )
                                      ]
                                      spids: [24042]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ ($ VSub_Name "$deplibs") (" "))}
                                                          )
                                                          (C {(${ VSub_Name SED)} {(-e)} 
                                                            {
                                                              (DQ ("s% -L") ($ VSub_Name "$path") 
                                                                (" % %g")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [24068 24089]
                                              )
                                            }
                                          spids: [24067]
                                        )
                                      ]
                                      spids: [24067]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dependency_libs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ ($ VSub_Name "$dependency_libs") 
                                                                (" ")
                                                              )
                                                            }
                                                          )
                                                          (C {(${ VSub_Name SED)} {(-e)} 
                                                            {
                                                              (DQ ("s% -L") ($ VSub_Name "$path") 
                                                                (" % %g")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [24093 24114]
                                              )
                                            }
                                          spids: [24092]
                                        )
                                      ]
                                      spids: [24092]
                                    )
                                  ]
                                  spids: [24039 24117]
                                )
                              spids: [24035 24037]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$xrpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:temp_xrpath)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [24139]
                                        )
                                      ]
                                      spids: [24139]
                                    )
                                    (ForEach
                                      iter_name: libdir
                                      iter_words: [{($ VSub_Name "$xrpath")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:temp_xrpath)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$temp_xrpath") (" -R") 
                                                        ($ VSub_Name "$libdir")
                                                      )
                                                    }
                                                  spids: [24154]
                                                )
                                              ]
                                              spids: [24154]
                                            )
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$finalize_rpath") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24172 24179 24181 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$finalize_rpath") 
                                                                (" ") ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [24187]
                                                        )
                                                      ]
                                                      spids: [24187]
                                                    )
                                                  ]
                                                  spids: [24184 24185 24194 -1]
                                                )
                                              ]
                                              spids: [24162 24169 24197]
                                            )
                                          ]
                                          spids: [24151 24200]
                                        )
                                      spids: [24147 24149]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} 
                                                      {(DQ ($ VSub_Name "$hardcode_into_libs"))} {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                    )
                                                    (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dependency_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$temp_xrpath") (" ") 
                                                        ($ VSub_Name "$dependency_libs")
                                                      )
                                                    }
                                                  spids: [24232]
                                                )
                                              ]
                                              spids: [24232]
                                            )
                                          ]
                                          spids: [-1 24229]
                                        )
                                      ]
                                      spids: [-1 24240]
                                    )
                                  ]
                                  spids: [-1 24132]
                                )
                              ]
                              spids: [-1 24243]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:old_dlfiles)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$dlfiles"))}
                                  spids: [24251]
                                )
                              ]
                              spids: [24251]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlfiles)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [24257]
                                )
                              ]
                              spids: [24257]
                            )
                            (ForEach
                              iter_name: lib
                              iter_words: [{($ VSub_Name "$old_dlfiles")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: 
                                        {
                                          (DQ (" ") ($ VSub_Name "$dlprefiles") (" ") 
                                            ($ VSub_Name "$dlfiles") (" ")
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$lib") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          spids: [24285 24292 24294 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlfiles)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$dlfiles") (" ") 
                                                        ($ VSub_Name "$lib")
                                                      )
                                                    }
                                                  spids: [24300]
                                                )
                                              ]
                                              spids: [24300]
                                            )
                                          ]
                                          spids: [24297 24298 24307 -1]
                                        )
                                      ]
                                      spids: [24272 24282 24310]
                                    )
                                  ]
                                  spids: [24269 24313]
                                )
                              spids: [24265 24267]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:old_dlprefiles)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$dlprefiles"))}
                                  spids: [24321]
                                )
                              ]
                              spids: [24321]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlprefiles)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [24327]
                                )
                              ]
                              spids: [24327]
                            )
                            (ForEach
                              iter_name: lib
                              iter_words: [{($ VSub_Name "$old_dlprefiles")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$dlprefiles") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$lib") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          spids: [24352 24359 24361 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlprefiles)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$dlprefiles") (" ") 
                                                        ($ VSub_Name "$lib")
                                                      )
                                                    }
                                                  spids: [24367]
                                                )
                                              ]
                                              spids: [24367]
                                            )
                                          ]
                                          spids: [24364 24365 24374 -1]
                                        )
                                      ]
                                      spids: [24342 24349 24377]
                                    )
                                  ]
                                  spids: [24339 24380]
                                )
                              spids: [24335 24337]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                          {(Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$rpath"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$host")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-os2) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-beos) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24421 24458 24465 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-rhapsody) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-darwin1.) 
                                                      (Lit_Other "[") (012) (Lit_Other "]")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$deplibs") 
                                                                (" -framework System")
                                                              )
                                                            }
                                                          spids: [24490]
                                                        )
                                                      ]
                                                      spids: [24490]
                                                    )
                                                  ]
                                                  spids: [24468 24483 24497 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-netbsd) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24500 24505 24512 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-openbsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-freebsd) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-dragonfly) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24515 24536 24543 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sco3.2v5) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sco5v6) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24546 24559 24566 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sysv4.2uw2) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-sysv5) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-unixware) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-OpenUNIX) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [24569 24598 24605 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$build_libtool_need_lc"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(DQ (yes))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$deplibs") 
                                                                        (" -lc")
                                                                      )
                                                                    }
                                                                  spids: [24634]
                                                                )
                                                              ]
                                                              spids: [24634]
                                                            )
                                                          ]
                                                          spids: [-1 24631]
                                                        )
                                                      ]
                                                      spids: [-1 24641]
                                                    )
                                                  ]
                                                  spids: [24608 24609 24644 -1]
                                                )
                                              ]
                                              spids: [24414 24418 24647]
                                            )
                                          ]
                                          spids: [-1 24411]
                                        )
                                      ]
                                      spids: [-1 24650]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:name_save)
                                          op: Equal
                                          rhs: {($ VSub_Name "$name")}
                                          spids: [24658]
                                        )
                                      ]
                                      spids: [24658]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libname_save)
                                          op: Equal
                                          rhs: {($ VSub_Name "$libname")}
                                          spids: [24662]
                                        )
                                      ]
                                      spids: [24662]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:release_save)
                                          op: Equal
                                          rhs: {($ VSub_Name "$release")}
                                          spids: [24666]
                                        )
                                      ]
                                      spids: [24666]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:versuffix_save)
                                          op: Equal
                                          rhs: {($ VSub_Name "$versuffix")}
                                          spids: [24670]
                                        )
                                      ]
                                      spids: [24670]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:major_save)
                                          op: Equal
                                          rhs: {($ VSub_Name "$major")}
                                          spids: [24674]
                                        )
                                      ]
                                      spids: [24674]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:release)
                                          op: Equal
                                          rhs: {(DQ )}
                                          spids: [24690]
                                        )
                                      ]
                                      spids: [24690]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:versuffix)
                                          op: Equal
                                          rhs: {(DQ )}
                                          spids: [24695]
                                        )
                                      ]
                                      spids: [24695]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:major)
                                          op: Equal
                                          rhs: {(DQ )}
                                          spids: [24700]
                                        )
                                      ]
                                      spids: [24700]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:newdeplibs)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [24705]
                                        )
                                      ]
                                      spids: [24705]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:droppeddeps)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [24708]
                                        )
                                      ]
                                      spids: [24708]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$deplibs_check_method")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(pass_all)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newdeplibs)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$deplibs")}
                                                  spids: [24743]
                                                )
                                              ]
                                              spids: [24743]
                                            )
                                          ]
                                          spids: [24719 24720 24747 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(test_compile)}]
                                          action: [
                                            (C {($ VSub_Name "$rm")} {(conftest.c)})
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {(conftest.c)}
                                                  spids: [24777]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: {(DQ ("\t  int main() { return 0; }\n"))}
                                                  do_expansion: True
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [24781]
                                                )
                                              ]
                                            )
                                            (C {($ VSub_Name "$rm")} {(conftest)})
                                            (C {($ VSub_Name "$LTCC")} {($ VSub_Name "$LTCFLAGS")} 
                                              {(-o)} {(conftest)} {(conftest.c)} {($ VSub_Name "$deplibs")}
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_QMark "$?"))} {(-eq)} 
                                                          {(0)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:ldd_output)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [(C {(ldd)} {(conftest)})]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [24822 24826]
                                                              )
                                                            }
                                                          spids: [24821]
                                                        )
                                                      ]
                                                      spids: [24821]
                                                    )
                                                    (ForEach
                                                      iter_name: i
                                                      iter_words: [{($ VSub_Name "$deplibs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (C {(expr)} 
                                                                                {($ VSub_Name "$i")} {(Lit_Other ":")} {(SQ <"-l\\(.*\\)">)}
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [24842 24852]
                                                                      )
                                                                    }
                                                                  spids: [24841]
                                                                )
                                                              ]
                                                              spids: [24841]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (AndOr
                                                                          children: [
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$name"
                                                                                  )
                                                                                )
                                                                              } {(KW_Bang "!") (Lit_Other "=")} {(DQ )}
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name 
"$name"
                                                                                  )
                                                                                )
                                                                              } {(-ne)} {(DQ (0))}
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ (X) 
                                                                                      ($ VSub_Name 
"$allow_libtool_libs_with_static_runtimes"
                                                                                      )
                                                                                    )
                                                                                  } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Case
                                                                              to_match: 
                                                                                {
                                                                                  (DQ (" ") 
                                                                                    ($ VSub_Name 
"$predeps"
                                                                                    ) (" ") ($ VSub_Name "$postdeps") (" ")
                                                                                  )
                                                                                }
                                                                              arms: [
                                                                                (case_arm
                                                                                  pat_list: [
                                                                                    {
                                                                                      (Lit_Other 
"*"
                                                                                      ) (DQ (" ") ($ VSub_Name "$i") (" ")) (Lit_Other "*")
                                                                                    }
                                                                                  ]
                                                                                  action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
newdeplibs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$newdeplibs"
                                                                                                ) (" ") ($ VSub_Name "$i")
                                                                                              )
                                                                                            }
                                                                                          spids: [
24934
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [24934]
                                                                                    )
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
i
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: {(DQ )}
                                                                                          spids: [
24942
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [24942]
                                                                                    )
                                                                                  ]
                                                                                  spids: [
24924
24931
24947
-1
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              spids: [
24911
24921
24950
                                                                              ]
                                                                            )
                                                                          ]
                                                                          spids: [-1 24908]
                                                                        )
                                                                      ]
                                                                      spids: [-1 24953]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-n)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$i"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: libname
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (C 
                                                                                                {
                                                                                                  (
eval
                                                                                                  )
                                                                                                } {(EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$echo")} 
                                                                                                {
                                                                                                  (EscapedLiteralPart
                                                                                                    token: 
                                                                                                      <
Lit_EscapedChar "\\\""
                                                                                                      >
                                                                                                  ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                                }
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
24972
24981
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [24971]
                                                                                )
                                                                              ]
                                                                              spids: [24971]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
deplib_matches
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (C 
                                                                                                {
                                                                                                  (
eval
                                                                                                  )
                                                                                                } {(EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$echo")} 
                                                                                                {
                                                                                                  (EscapedLiteralPart
                                                                                                    token: 
                                                                                                      <
Lit_EscapedChar "\\\""
                                                                                                      >
                                                                                                  ) ($ VSub_Name "$library_names_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                                }
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
24985
24994
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [24984]
                                                                                )
                                                                              ]
                                                                              spids: [24984]
                                                                            )
                                                                            (C {(set)} {(dummy)} 
                                                                              {
                                                                                ($ VSub_Name 
"$deplib_matches"
                                                                                )
                                                                              }
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
deplib_match
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ VSub_Number 
"$2"
                                                                                      )
                                                                                    }
                                                                                  spids: [25004]
                                                                                )
                                                                              ]
                                                                              spids: [25004]
                                                                            )
                                                                            (If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {
                                                                                            (CommandSubPart
                                                                                              command_list: 
                                                                                                (CommandList
                                                                                                  children: [
                                                                                                    (C 
                                                                                                      {
                                                                                                        (
expr
                                                                                                        )
                                                                                                      } {(DQ ($ VSub_Name "$ldd_output"))} {(Lit_Other ":")} {(DQ (".*") ($ VSub_Name "$deplib_match"))}
                                                                                                    )
                                                                                                  ]
                                                                                                )
                                                                                              left_token: 
                                                                                                <
Left_Backtick "`"
                                                                                                >
                                                                                              spids: [
25012
25025
                                                                                              ]
                                                                                            )
                                                                                          } {(-ne)} {(0)}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi 
";"
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
newdeplibs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$newdeplibs"
                                                                                                ) (" ") ($ VSub_Name "$i")
                                                                                              )
                                                                                            }
                                                                                          spids: [
25036
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [25036]
                                                                                    )
                                                                                  ]
                                                                                  spids: [-1 25033]
                                                                                )
                                                                              ]
                                                                              else_action: [
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
droppeddeps
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: {(yes)}
                                                                                      spids: [25047]
                                                                                    )
                                                                                  ]
                                                                                  spids: [25047]
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  }
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** Warning: dynamic linker does not accept needed library ") ($ VSub_Name "$i") (.))}
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** I have the capability to make that library automatically link in when"))}
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** you link to this library.  But I can only do this if you have a"))}
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** shared version of the library, which I believe you do not have"))}
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** because a test_compile did reveal that the linker did not use it for"))}
                                                                                )
                                                                                (C 
                                                                                  {
                                                                                    ($ VSub_Name 
"$echo"
                                                                                    )
                                                                                  } {(DQ ("*** its dynamic dependency list that programs get resolved with at runtime."))}
                                                                                )
                                                                              ]
                                                                              spids: [25044 25098]
                                                                            )
                                                                          ]
                                                                          spids: [-1 24968]
                                                                        )
                                                                      ]
                                                                      spids: [-1 25101]
                                                                    )
                                                                  ]
                                                                  spids: [-1 24888]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:newdeplibs)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$newdeplibs"
                                                                            ) (" ") ($ VSub_Name "$i")
                                                                          )
                                                                        }
                                                                      spids: [25107]
                                                                    )
                                                                  ]
                                                                  spids: [25107]
                                                                )
                                                              ]
                                                              spids: [25104 25115]
                                                            )
                                                          ]
                                                          spids: [24838 25118]
                                                        )
                                                      spids: [24834 24836]
                                                    )
                                                  ]
                                                  spids: [-1 24818]
                                                )
                                              ]
                                              else_action: [
                                                (ForEach
                                                  iter_name: i
                                                  iter_words: [{($ VSub_Name "$deplibs")}]
                                                  do_arg_iter: False
                                                  body: 
                                                    (DoGroup
                                                      children: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:name)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (CommandSubPart
                                                                    command_list: 
                                                                      (CommandList
                                                                        children: [
                                                                          (C {(expr)} 
                                                                            {($ VSub_Name "$i")} {(Lit_Other ":")} {(SQ <"-l\\(.*\\)">)}
                                                                          )
                                                                        ]
                                                                      )
                                                                    left_token: <Left_Backtick "`">
                                                                    spids: [25145 25155]
                                                                  )
                                                                }
                                                              spids: [25144]
                                                            )
                                                          ]
                                                          spids: [25144]
                                                        )
                                                        (If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (Sentence
                                                                  child: 
                                                                    (AndOr
                                                                      children: [
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ ($ VSub_Name "$name"))
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(DQ )}
                                                                        )
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ ($ VSub_Name "$name"))
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(DQ (0))}
                                                                        )
                                                                      ]
                                                                      op_id: Op_DAmp
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              action: [
                                                                (C {($ VSub_Name "$rm")} {(conftest)})
                                                                (C {($ VSub_Name "$LTCC")} 
                                                                  {($ VSub_Name "$LTCFLAGS")} {(-o)} {(conftest)} {(conftest.c)} {($ VSub_Name "$i")}
                                                                )
                                                                (If
                                                                  arms: [
                                                                    (if_arm
                                                                      cond: [
                                                                        (Sentence
                                                                          child: 
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_QMark "$?")
                                                                                )
                                                                              } {(-eq)} {(0)}
                                                                            )
                                                                          terminator: <Op_Semi ";">
                                                                        )
                                                                      ]
                                                                      action: [
                                                                        (Assignment
                                                                          keyword: Assign_None
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (LhsName
                                                                                  name: ldd_output
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (CommandSubPart
                                                                                    command_list: 
                                                                                      (CommandList
                                                                                        children: [
                                                                                          (C {(ldd)} 
                                                                                            {
                                                                                              (
conftest
                                                                                              )
                                                                                            }
                                                                                          )
                                                                                        ]
                                                                                      )
                                                                                    left_token: 
                                                                                      <
Left_Backtick "`"
                                                                                      >
                                                                                    spids: [
25235
25239
                                                                                    ]
                                                                                  )
                                                                                }
                                                                              spids: [25234]
                                                                            )
                                                                          ]
                                                                          spids: [25234]
                                                                        )
                                                                        (If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (Sentence
                                                                                  child: 
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ (X) 
                                                                                          ($ 
VSub_Name "$allow_libtool_libs_with_static_runtimes"
                                                                                          )
                                                                                        )
                                                                                      } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ";">
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (Case
                                                                                  to_match: 
                                                                                    {
                                                                                      (DQ (" ") 
                                                                                        ($ VSub_Name 
"$predeps"
                                                                                        ) (" ") ($ VSub_Name "$postdeps") (" ")
                                                                                      )
                                                                                    }
                                                                                  arms: [
                                                                                    (case_arm
                                                                                      pat_list: [
                                                                                        {
                                                                                          (
Lit_Other "*"
                                                                                          ) (DQ (" ") ($ VSub_Name "$i") (" ")) (Lit_Other "*")
                                                                                        }
                                                                                      ]
                                                                                      action: [
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
newdeplibs
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$newdeplibs"
                                                                                                    ) (" ") ($ VSub_Name "$i")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
25285
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
25285
                                                                                          ]
                                                                                        )
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
i
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: {(DQ )}
                                                                                              spids: [
25293
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
25293
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
25275
25282
25298
-1
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [
25262
25272
25301
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              spids: [-1 25259]
                                                                            )
                                                                          ]
                                                                          spids: [-1 25304]
                                                                        )
                                                                        (If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (Sentence
                                                                                  child: 
                                                                                    (C {(test)} {(-n)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$i"
                                                                                          )
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ";">
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
libname
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (CommandSubPart
                                                                                            command_list: 
                                                                                              (CommandList
                                                                                                children: [
                                                                                                  (C 
                                                                                                    {
                                                                                                      (
eval
                                                                                                      )
                                                                                                    } {(EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$echo")} 
                                                                                                    {
                                                                                                      (EscapedLiteralPart
                                                                                                        token: 
                                                                                                          <
Lit_EscapedChar "\\\""
                                                                                                          >
                                                                                                      ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                                    }
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            left_token: 
                                                                                              <
Left_Backtick "`"
                                                                                              >
                                                                                            spids: [
25323
25332
                                                                                            ]
                                                                                          )
                                                                                        }
                                                                                      spids: [25322]
                                                                                    )
                                                                                  ]
                                                                                  spids: [25322]
                                                                                )
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
deplib_matches
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (CommandSubPart
                                                                                            command_list: 
                                                                                              (CommandList
                                                                                                children: [
                                                                                                  (C 
                                                                                                    {
                                                                                                      (
eval
                                                                                                      )
                                                                                                    } {(EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$echo")} 
                                                                                                    {
                                                                                                      (EscapedLiteralPart
                                                                                                        token: 
                                                                                                          <
Lit_EscapedChar "\\\""
                                                                                                          >
                                                                                                      ) ($ VSub_Name "$library_names_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                                    }
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            left_token: 
                                                                                              <
Left_Backtick "`"
                                                                                              >
                                                                                            spids: [
25336
25345
                                                                                            ]
                                                                                          )
                                                                                        }
                                                                                      spids: [25335]
                                                                                    )
                                                                                  ]
                                                                                  spids: [25335]
                                                                                )
                                                                                (C {(set)} {(dummy)} 
                                                                                  {
                                                                                    ($ VSub_Name 
"$deplib_matches"
                                                                                    )
                                                                                  }
                                                                                )
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
deplib_match
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          ($ 
VSub_Number "$2"
                                                                                          )
                                                                                        }
                                                                                      spids: [25355]
                                                                                    )
                                                                                  ]
                                                                                  spids: [25355]
                                                                                )
                                                                                (If
                                                                                  arms: [
                                                                                    (if_arm
                                                                                      cond: [
                                                                                        (Sentence
                                                                                          child: 
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } 
                                                                                              {
                                                                                                (CommandSubPart
                                                                                                  command_list: 
                                                                                                    (CommandList
                                                                                                      children: [
                                                                                                        (C 
                                                                                                          {
                                                                                                            (
expr
                                                                                                            )
                                                                                                          } {(DQ ($ VSub_Name "$ldd_output"))} {(Lit_Other ":")} {(DQ (".*") ($ VSub_Name "$deplib_match"))}
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                  left_token: 
                                                                                                    <
Left_Backtick "`"
                                                                                                    >
                                                                                                  spids: [
25363
25376
                                                                                                  ]
                                                                                                )
                                                                                              } {(-ne)} {(0)}
                                                                                            )
                                                                                          terminator: 
                                                                                            <
Op_Semi ";"
                                                                                            >
                                                                                        )
                                                                                      ]
                                                                                      action: [
                                                                                        (Assignment
                                                                                          keyword: 
Assign_None
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (LhsName
                                                                                                  name: 
newdeplibs
                                                                                                )
                                                                                              op: 
                                                                                                Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$newdeplibs"
                                                                                                    ) (" ") ($ VSub_Name "$i")
                                                                                                  )
                                                                                                }
                                                                                              spids: [
25387
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
25387
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
25384
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  else_action: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
droppeddeps
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: {(yes)}
                                                                                          spids: [
25398
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [25398]
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** Warning: dynamic linker does not accept needed library ") ($ VSub_Name "$i") (.))}
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** I have the capability to make that library automatically link in when"))}
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** you link to this library.  But I can only do this if you have a"))}
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** shared version of the library, which you do not appear to have"))}
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** because a test_compile did reveal that the linker did not use this one"))}
                                                                                    )
                                                                                    (C 
                                                                                      {
                                                                                        ($ VSub_Name 
"$echo"
                                                                                        )
                                                                                      } {(DQ ("*** as a dynamic dependency that programs can get resolved with at runtime."))}
                                                                                    )
                                                                                  ]
                                                                                  spids: [25395 25449]
                                                                                )
                                                                              ]
                                                                              spids: [-1 25319]
                                                                            )
                                                                          ]
                                                                          spids: [-1 25452]
                                                                        )
                                                                      ]
                                                                      spids: [-1 25231]
                                                                    )
                                                                  ]
                                                                  else_action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: droppeddeps
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(yes)}
                                                                          spids: [25458]
                                                                        )
                                                                      ]
                                                                      spids: [25458]
                                                                    )
                                                                    (C {($ VSub_Name "$echo")})
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** Warning!  Library "
                                                                          ) ($ VSub_Name "$i") (" is needed by this library but I was not able to")
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"***  make it link in!  You will probably need to install it or some"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** library that it depends on before this library will be fully"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** functional.  Installing it before continuing would be even better."
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [25455 25495]
                                                                )
                                                              ]
                                                              spids: [-1 25192]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:newdeplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$newdeplibs") 
                                                                        (" ") ($ VSub_Name "$i")
                                                                      )
                                                                    }
                                                                  spids: [25501]
                                                                )
                                                              ]
                                                              spids: [25501]
                                                            )
                                                          ]
                                                          spids: [25498 25509]
                                                        )
                                                      ]
                                                      spids: [25141 25512]
                                                    )
                                                  spids: [25137 25139]
                                                )
                                              ]
                                              spids: [25121 25515]
                                            )
                                          ]
                                          spids: [24750 24751 25518 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(file_magic) (Lit_Other "*")}]
                                          action: [
                                            (C {(set)} {(dummy)} {($ VSub_Name "$deplibs_check_method")})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:file_magic_regex)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(expr)} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_Name 
"$deplibs_check_method"
                                                                    )
                                                                  )
                                                                } {(Lit_Other ":")} 
                                                                {
                                                                  (DQ ($ VSub_Number "$2") (" ") 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar "\\(">
                                                                    ) (".*") (EscapedLiteralPart token:<Lit_EscapedChar "\\)">)
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [25534 25550]
                                                      )
                                                    }
                                                  spids: [25533]
                                                )
                                              ]
                                              spids: [25533]
                                            )
                                            (ForEach
                                              iter_name: a_deplib
                                              iter_words: [{($ VSub_Name "$deplibs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:name)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (C {(expr)} 
                                                                        {($ VSub_Name "$a_deplib")} {(Lit_Other ":")} {(SQ <"-l\\(.*\\)">)}
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [25566 25576]
                                                              )
                                                            }
                                                          spids: [25565]
                                                        )
                                                      ]
                                                      spids: [25565]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {(DQ ($ VSub_Name "$name"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ )}
                                                                    )
                                                                    (C {(test)} 
                                                                      {(DQ ($ VSub_Name "$name"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ (0))}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ (X) 
                                                                              ($ VSub_Name 
"$allow_libtool_libs_with_static_runtimes"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ (" ") 
                                                                            ($ VSub_Name "$predeps") (" ") ($ VSub_Name "$postdeps") (" ")
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") 
                                                                              (DQ (" ") 
                                                                                ($ VSub_Name 
"$a_deplib"
                                                                                ) (" ")
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
newdeplibs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$newdeplibs"
                                                                                        ) (" ") ($ VSub_Name "$a_deplib")
                                                                                      )
                                                                                    }
                                                                                  spids: [25659]
                                                                                )
                                                                              ]
                                                                              spids: [25659]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: a_deplib
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(DQ )}
                                                                                  spids: [25667]
                                                                                )
                                                                              ]
                                                                              spids: [25667]
                                                                            )
                                                                          ]
                                                                          spids: [25649 25656 25672 -1]
                                                                        )
                                                                      ]
                                                                      spids: [25636 25646 25675]
                                                                    )
                                                                  ]
                                                                  spids: [-1 25633]
                                                                )
                                                              ]
                                                              spids: [-1 25678]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$a_deplib"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:libname)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (C {(eval)} 
                                                                                        {
                                                                                          (EscapedLiteralPart
                                                                                            token: 
                                                                                              <
Lit_EscapedChar "\\\\"
                                                                                              >
                                                                                          ) ($ VSub_Name "$echo")
                                                                                        } 
                                                                                        {
                                                                                          (EscapedLiteralPart
                                                                                            token: 
                                                                                              <
Lit_EscapedChar "\\\""
                                                                                              >
                                                                                          ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                        }
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [25697 25706]
                                                                              )
                                                                            }
                                                                          spids: [25696]
                                                                        )
                                                                      ]
                                                                      spids: [25696]
                                                                    )
                                                                    (ForEach
                                                                      iter_name: i
                                                                      iter_words: [
                                                                        {
                                                                          ($ VSub_Name 
"$lib_search_path"
                                                                          )
                                                                        }
                                                                        {
                                                                          ($ VSub_Name 
"$sys_lib_search_path"
                                                                          )
                                                                        }
                                                                        {
                                                                          ($ VSub_Name 
"$shlib_search_path"
                                                                          )
                                                                        }
                                                                      ]
                                                                      do_arg_iter: False
                                                                      body: 
                                                                        (DoGroup
                                                                          children: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
potential_libs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (SimpleCommand
                                                                                                words: [
                                                                                                  {
                                                                                                    (
ls
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    ($ 
VSub_Name "$i"
                                                                                                    ) (/) ($ VSub_Name "$libname") (Lit_Other "[") (.-) (Lit_Other "]") (Lit_Other "*")
                                                                                                  }
                                                                                                ]
                                                                                                redirects: [
                                                                                                  (Redir
                                                                                                    op_id: 
Redir_Great
                                                                                                    fd: 
2
                                                                                                    arg_word: 
                                                                                                      {
                                                                                                        (
/dev/null
                                                                                                        )
                                                                                                      }
                                                                                                    spids: [
25737
                                                                                                    ]
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
25726
25739
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [25725]
                                                                                )
                                                                              ]
                                                                              spids: [25725]
                                                                            )
                                                                            (ForEach
                                                                              iter_name: potent_lib
                                                                              iter_words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$potential_libs"
                                                                                  )
                                                                                }
                                                                              ]
                                                                              do_arg_iter: False
                                                                              body: 
                                                                                (DoGroup
                                                                                  children: [
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (Pipeline
                                                                                                  children: [
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          (
ls
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (
-lLd
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (DQ 
                                                                                                            ($ 
VSub_Name "$potent_lib"
                                                                                                            )
                                                                                                          )
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
2
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
25768
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          (
grep
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (DQ 
                                                                                                            (
" -> "
                                                                                                            )
                                                                                                          )
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
-1
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
25781
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                  negated: 
False
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (ControlFlow
                                                                                              token: 
                                                                                                <
ControlFlow_Continue continue
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
25785
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
25791
                                                                                      ]
                                                                                    )
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
potlib
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$potent_lib"
                                                                                                )
                                                                                              )
                                                                                            }
                                                                                          spids: [
25814
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [25814]
                                                                                    )
                                                                                    (While
                                                                                      cond: [
                                                                                        (Sentence
                                                                                          child: 
                                                                                            (SimpleCommand
                                                                                              words: [
                                                                                                {
                                                                                                  (
test
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (
-h
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_Name "$potlib"
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (Redir
                                                                                                  op_id: 
Redir_Great
                                                                                                  fd: 
2
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
25830
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          terminator: 
                                                                                            <
Op_Semi ";"
                                                                                            >
                                                                                        )
                                                                                      ]
                                                                                      body: 
                                                                                        (DoGroup
                                                                                          children: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
potliblink
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (CommandSubPart
                                                                                                        command_list: 
                                                                                                          (CommandList
                                                                                                            children: [
                                                                                                              (Pipeline
                                                                                                                children: [
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      (
ls
                                                                                                                      )
                                                                                                                    } {(-ld)} {($ VSub_Name "$potlib")}
                                                                                                                  )
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      (${ 
VSub_Name SED
                                                                                                                      )
                                                                                                                    } {(SQ <"s/.* -> //">)}
                                                                                                                  )
                                                                                                                ]
                                                                                                                negated: 
False
                                                                                                              )
                                                                                                            ]
                                                                                                          )
                                                                                                        left_token: 
                                                                                                          <
Left_Backtick "`"
                                                                                                          >
                                                                                                        spids: [
25838
25854
                                                                                                        ]
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
25837
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
25837
                                                                                              ]
                                                                                            )
                                                                                            (Case
                                                                                              to_match: 
                                                                                                {
                                                                                                  ($ 
VSub_Name "$potliblink"
                                                                                                  )
                                                                                                }
                                                                                              arms: [
                                                                                                (case_arm
                                                                                                  pat_list: [
                                                                                                    {
                                                                                                      (
Lit_Other "["
                                                                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                                                                                    }
                                                                                                    {
                                                                                                      (
Lit_Other "["
                                                                                                      ) (A-Za-z) (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") 
                                                                                                      (EscapedLiteralPart
                                                                                                        token: 
                                                                                                          <
Lit_EscapedChar "\\\\"
                                                                                                          >
                                                                                                      ) (/) (Lit_Other "]") (Lit_Other "*")
                                                                                                    }
                                                                                                  ]
                                                                                                  action: [
                                                                                                    (Assignment
                                                                                                      keyword: 
Assign_None
                                                                                                      pairs: [
                                                                                                        (assign_pair
                                                                                                          lhs: 
                                                                                                            (LhsName
                                                                                                              name: 
potlib
                                                                                                            )
                                                                                                          op: 
                                                                                                            Equal
                                                                                                          rhs: 
                                                                                                            {
                                                                                                              (DQ 
                                                                                                                ($ 
VSub_Name "$potliblink"
                                                                                                                )
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
25883
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                      spids: [
25883
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                  spids: [
25864
25881
25887
-1
                                                                                                  ]
                                                                                                )
                                                                                                (case_arm
                                                                                                  pat_list: [
                                                                                                    {
                                                                                                      (
Lit_Other "*"
                                                                                                      )
                                                                                                    }
                                                                                                  ]
                                                                                                  action: [
                                                                                                    (Assignment
                                                                                                      keyword: 
Assign_None
                                                                                                      pairs: [
                                                                                                        (assign_pair
                                                                                                          lhs: 
                                                                                                            (LhsName
                                                                                                              name: 
potlib
                                                                                                            )
                                                                                                          op: 
                                                                                                            Equal
                                                                                                          rhs: 
                                                                                                            {
                                                                                                              (CommandSubPart
                                                                                                                command_list: 
                                                                                                                  (CommandList
                                                                                                                    children: [
                                                                                                                      (Pipeline
                                                                                                                        children: [
                                                                                                                          (C 
                                                                                                                            {
                                                                                                                              ($ 
VSub_Name "$echo"
                                                                                                                              )
                                                                                                                            } {(DQ (X) ($ VSub_Name "$potlib"))}
                                                                                                                          )
                                                                                                                          (C 
                                                                                                                            {
                                                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                                                              )
                                                                                                                            } {(-e)} {(SQ <"s,[^/]*$,,">)}
                                                                                                                          )
                                                                                                                        ]
                                                                                                                        negated: 
False
                                                                                                                      )
                                                                                                                    ]
                                                                                                                  )
                                                                                                                left_token: 
                                                                                                                  <
Left_Backtick "`"
                                                                                                                  >
                                                                                                                spids: [
25894
25911
                                                                                                                ]
                                                                                                              ) (DQ ($ VSub_Name "$potliblink"))
                                                                                                            }
                                                                                                          spids: [
25893
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                      spids: [
25893
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                  spids: [
25890
25891
25915
-1
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
25857
25861
25918
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          spids: [
25834
25921
                                                                                          ]
                                                                                        )
                                                                                    )
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (Pipeline
                                                                                                  children: [
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          (
eval
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$file_magic_cmd"
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (EscapedLiteralPart
                                                                                                            token: 
                                                                                                              <
Lit_EscapedChar "\\\""
                                                                                                              >
                                                                                                          ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (potlib) 
                                                                                                          (EscapedLiteralPart
                                                                                                            token: 
                                                                                                              <
Lit_EscapedChar "\\\""
                                                                                                              >
                                                                                                          )
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
2
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
25935
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                    (C 
                                                                                                      {
                                                                                                        (${ 
VSub_Name SED
                                                                                                        )
                                                                                                      } {(10q)}
                                                                                                    )
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$EGREP"
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (DQ 
                                                                                                            ($ 
VSub_Name "$file_magic_regex"
                                                                                                            )
                                                                                                          )
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
-1
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
25958
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                  negated: 
False
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
newdeplibs
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (DQ 
                                                                                                        ($ 
VSub_Name "$newdeplibs"
                                                                                                        ) (" ") ($ VSub_Name "$a_deplib")
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
25966
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
25966
                                                                                              ]
                                                                                            )
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
a_deplib
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: {(DQ )}
                                                                                                  spids: [
25974
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
25974
                                                                                              ]
                                                                                            )
                                                                                            (ControlFlow
                                                                                              token: 
                                                                                                <
ControlFlow_Break break
                                                                                                >
                                                                                              arg_word: 
                                                                                                {
                                                                                                  (
2
                                                                                                  )
                                                                                                }
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
25963
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
25984
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [25751 25987]
                                                                                )
                                                                              spids: [25747 25749]
                                                                            )
                                                                          ]
                                                                          spids: [25722 25990]
                                                                        )
                                                                      spids: [25714 25720]
                                                                    )
                                                                  ]
                                                                  spids: [-1 25693]
                                                                )
                                                              ]
                                                              spids: [-1 25993]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$a_deplib"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: droppeddeps
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(yes)}
                                                                          spids: [26011]
                                                                        )
                                                                      ]
                                                                      spids: [26011]
                                                                    )
                                                                    (C {($ VSub_Name "$echo")})
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** Warning: linker path does not have real file for library "
                                                                          ) ($ VSub_Name "$a_deplib") (.)
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** I have the capability to make that library automatically link in when"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** you link to this library.  But I can only do this if you have a"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** shared version of the library, which you do not appear to have"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** because I did check the linker path looking for a file starting"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-z)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$potlib"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {($ VSub_Name "$echo")} 
                                                                              {
                                                                                (DQ ("*** with ") 
                                                                                  ($ VSub_Name 
"$libname"
                                                                                  ) (" but no candidates were found. (...for file magic test)")
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [-1 26067]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (C {($ VSub_Name "$echo")} 
                                                                          {
                                                                            (DQ ("*** with ") 
                                                                              ($ VSub_Name "$libname") (" and none of the candidates passed a file format test")
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {($ VSub_Name "$echo")} 
                                                                          {
                                                                            (DQ 
                                                                              (
"*** using a file magic. Last file checked: "
                                                                              ) ($ VSub_Name "$potlib")
                                                                            )
                                                                          }
                                                                        )
                                                                      ]
                                                                      spids: [26079 26099]
                                                                    )
                                                                  ]
                                                                  spids: [-1 26008]
                                                                )
                                                              ]
                                                              spids: [-1 26102]
                                                            )
                                                          ]
                                                          spids: [-1 25613]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdeplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$newdeplibs") 
                                                                    (" ") ($ VSub_Name "$a_deplib")
                                                                  )
                                                                }
                                                              spids: [26112]
                                                            )
                                                          ]
                                                          spids: [26112]
                                                        )
                                                      ]
                                                      spids: [26105 26120]
                                                    )
                                                  ]
                                                  spids: [25562 26123]
                                                )
                                              spids: [25558 25560]
                                            )
                                          ]
                                          spids: [25521 25523 26129 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(match_pattern) (Lit_Other "*")}]
                                          action: [
                                            (C {(set)} {(dummy)} {($ VSub_Name "$deplibs_check_method")})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:match_pattern_regex)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(expr)} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_Name 
"$deplibs_check_method"
                                                                    )
                                                                  )
                                                                } {(Lit_Other ":")} 
                                                                {
                                                                  (DQ ($ VSub_Number "$2") (" ") 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar "\\(">
                                                                    ) (".*") (EscapedLiteralPart token:<Lit_EscapedChar "\\)">)
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [26145 26161]
                                                      )
                                                    }
                                                  spids: [26144]
                                                )
                                              ]
                                              spids: [26144]
                                            )
                                            (ForEach
                                              iter_name: a_deplib
                                              iter_words: [{($ VSub_Name "$deplibs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:name)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (C {(expr)} 
                                                                        {($ VSub_Name "$a_deplib")} {(Lit_Other ":")} {(SQ <"-l\\(.*\\)">)}
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [26177 26187]
                                                              )
                                                            }
                                                          spids: [26176]
                                                        )
                                                      ]
                                                      spids: [26176]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} {(-n)} 
                                                                      {(DQ ($ VSub_Name "$name"))}
                                                                    )
                                                                    (C {(test)} 
                                                                      {(DQ ($ VSub_Name "$name"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ (0))}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ (X) 
                                                                              ($ VSub_Name 
"$allow_libtool_libs_with_static_runtimes"
                                                                              )
                                                                            )
                                                                          } {(Lit_Other "=")} {(DQ (Xyes))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ (" ") 
                                                                            ($ VSub_Name "$predeps") (" ") ($ VSub_Name "$postdeps") (" ")
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Other "*") 
                                                                              (DQ (" ") 
                                                                                ($ VSub_Name 
"$a_deplib"
                                                                                ) (" ")
                                                                              ) (Lit_Other "*")
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
newdeplibs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$newdeplibs"
                                                                                        ) (" ") ($ VSub_Name "$a_deplib")
                                                                                      )
                                                                                    }
                                                                                  spids: [26266]
                                                                                )
                                                                              ]
                                                                              spids: [26266]
                                                                            )
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: a_deplib
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(DQ )}
                                                                                  spids: [26274]
                                                                                )
                                                                              ]
                                                                              spids: [26274]
                                                                            )
                                                                          ]
                                                                          spids: [26256 26263 26279 -1]
                                                                        )
                                                                      ]
                                                                      spids: [26243 26253 26282]
                                                                    )
                                                                  ]
                                                                  spids: [-1 26240]
                                                                )
                                                              ]
                                                              spids: [-1 26285]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$a_deplib"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:libname)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (C {(eval)} 
                                                                                        {
                                                                                          (EscapedLiteralPart
                                                                                            token: 
                                                                                              <
Lit_EscapedChar "\\\\"
                                                                                              >
                                                                                          ) ($ VSub_Name "$echo")
                                                                                        } 
                                                                                        {
                                                                                          (EscapedLiteralPart
                                                                                            token: 
                                                                                              <
Lit_EscapedChar "\\\""
                                                                                              >
                                                                                          ) ($ VSub_Name "$libname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                        }
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [26304 26313]
                                                                              )
                                                                            }
                                                                          spids: [26303]
                                                                        )
                                                                      ]
                                                                      spids: [26303]
                                                                    )
                                                                    (ForEach
                                                                      iter_name: i
                                                                      iter_words: [
                                                                        {
                                                                          ($ VSub_Name 
"$lib_search_path"
                                                                          )
                                                                        }
                                                                        {
                                                                          ($ VSub_Name 
"$sys_lib_search_path"
                                                                          )
                                                                        }
                                                                        {
                                                                          ($ VSub_Name 
"$shlib_search_path"
                                                                          )
                                                                        }
                                                                      ]
                                                                      do_arg_iter: False
                                                                      body: 
                                                                        (DoGroup
                                                                          children: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
potential_libs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (SimpleCommand
                                                                                                words: [
                                                                                                  {
                                                                                                    (
ls
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    ($ 
VSub_Name "$i"
                                                                                                    ) (/) ($ VSub_Name "$libname") (Lit_Other "[") (.-) (Lit_Other "]") (Lit_Other "*")
                                                                                                  }
                                                                                                ]
                                                                                                redirects: [
                                                                                                  (Redir
                                                                                                    op_id: 
Redir_Great
                                                                                                    fd: 
2
                                                                                                    arg_word: 
                                                                                                      {
                                                                                                        (
/dev/null
                                                                                                        )
                                                                                                      }
                                                                                                    spids: [
26344
                                                                                                    ]
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
26333
26346
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [26332]
                                                                                )
                                                                              ]
                                                                              spids: [26332]
                                                                            )
                                                                            (ForEach
                                                                              iter_name: potent_lib
                                                                              iter_words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$potential_libs"
                                                                                  )
                                                                                }
                                                                              ]
                                                                              do_arg_iter: False
                                                                              body: 
                                                                                (DoGroup
                                                                                  children: [
                                                                                    (Assignment
                                                                                      keyword: 
Assign_None
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (LhsName
                                                                                              name: 
potlib
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_Name "$potent_lib"
                                                                                                )
                                                                                              )
                                                                                            }
                                                                                          spids: [
26361
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [26361]
                                                                                    )
                                                                                    (If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (Sentence
                                                                                              child: 
                                                                                                (Pipeline
                                                                                                  children: [
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          (
eval
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$echo"
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (EscapedLiteralPart
                                                                                                            token: 
                                                                                                              <
Lit_EscapedChar "\\\""
                                                                                                              >
                                                                                                          ) ($ VSub_Name "$potent_lib") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
2
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
26380
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                    (C 
                                                                                                      {
                                                                                                        (${ 
VSub_Name SED
                                                                                                        )
                                                                                                      } {(10q)}
                                                                                                    )
                                                                                                    (SimpleCommand
                                                                                                      words: [
                                                                                                        {
                                                                                                          ($ 
VSub_Name "$EGREP"
                                                                                                          )
                                                                                                        }
                                                                                                        {
                                                                                                          (DQ 
                                                                                                            ($ 
VSub_Name "$match_pattern_regex"
                                                                                                            )
                                                                                                          )
                                                                                                        }
                                                                                                      ]
                                                                                                      redirects: [
                                                                                                        (Redir
                                                                                                          op_id: 
Redir_Great
                                                                                                          fd: 
-1
                                                                                                          arg_word: 
                                                                                                            {
                                                                                                              (
/dev/null
                                                                                                              )
                                                                                                            }
                                                                                                          spids: [
26403
                                                                                                          ]
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                  negated: 
False
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ";"
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
newdeplibs
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (DQ 
                                                                                                        ($ 
VSub_Name "$newdeplibs"
                                                                                                        ) (" ") ($ VSub_Name "$a_deplib")
                                                                                                      )
                                                                                                    }
                                                                                                  spids: [
26411
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
26411
                                                                                              ]
                                                                                            )
                                                                                            (Assignment
                                                                                              keyword: 
Assign_None
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (LhsName
                                                                                                      name: 
a_deplib
                                                                                                    )
                                                                                                  op: 
                                                                                                    Equal
                                                                                                  rhs: {(DQ )}
                                                                                                  spids: [
26419
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                              spids: [
26419
                                                                                              ]
                                                                                            )
                                                                                            (ControlFlow
                                                                                              token: 
                                                                                                <
ControlFlow_Break break
                                                                                                >
                                                                                              arg_word: 
                                                                                                {
                                                                                                  (
2
                                                                                                  )
                                                                                                }
                                                                                            )
                                                                                          ]
                                                                                          spids: [
-1
26408
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      spids: [
-1
26429
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  spids: [26358 26432]
                                                                                )
                                                                              spids: [26354 26356]
                                                                            )
                                                                          ]
                                                                          spids: [26329 26435]
                                                                        )
                                                                      spids: [26321 26327]
                                                                    )
                                                                  ]
                                                                  spids: [-1 26300]
                                                                )
                                                              ]
                                                              spids: [-1 26438]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$a_deplib"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: droppeddeps
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(yes)}
                                                                          spids: [26456]
                                                                        )
                                                                      ]
                                                                      spids: [26456]
                                                                    )
                                                                    (C {($ VSub_Name "$echo")})
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** Warning: linker path does not have real file for library "
                                                                          ) ($ VSub_Name "$a_deplib") (.)
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** I have the capability to make that library automatically link in when"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** you link to this library.  But I can only do this if you have a"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** shared version of the library, which you do not appear to have"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$echo")} 
                                                                      {
                                                                        (DQ 
                                                                          (
"*** because I did check the linker path looking for a file starting"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-z)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$potlib"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {($ VSub_Name "$echo")} 
                                                                              {
                                                                                (DQ ("*** with ") 
                                                                                  ($ VSub_Name 
"$libname"
                                                                                  ) (" but no candidates were found. (...for regex pattern test)")
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [-1 26512]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (C {($ VSub_Name "$echo")} 
                                                                          {
                                                                            (DQ ("*** with ") 
                                                                              ($ VSub_Name "$libname") (" and none of the candidates passed a file format test")
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {($ VSub_Name "$echo")} 
                                                                          {
                                                                            (DQ 
                                                                              (
"*** using a regex pattern. Last file checked: "
                                                                              ) ($ VSub_Name "$potlib")
                                                                            )
                                                                          }
                                                                        )
                                                                      ]
                                                                      spids: [26524 26544]
                                                                    )
                                                                  ]
                                                                  spids: [-1 26453]
                                                                )
                                                              ]
                                                              spids: [-1 26547]
                                                            )
                                                          ]
                                                          spids: [-1 26220]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdeplibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$newdeplibs") 
                                                                    (" ") ($ VSub_Name "$a_deplib")
                                                                  )
                                                                }
                                                              spids: [26557]
                                                            )
                                                          ]
                                                          spids: [26557]
                                                        )
                                                      ]
                                                      spids: [26550 26565]
                                                    )
                                                  ]
                                                  spids: [26173 26568]
                                                )
                                              spids: [26169 26171]
                                            )
                                          ]
                                          spids: [26132 26134 26574 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(none)} {(unknown)} {(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newdeplibs)
                                                  op: Equal
                                                  rhs: {(DQ )}
                                                  spids: [26589]
                                                )
                                              ]
                                              spids: [26589]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tmp_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ ("X ") 
                                                                        ($ VSub_Name "$deplibs")
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s/ -lc$//">)} {(-e)} {(SQ <"s/ -[LR][^ ]*//g">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [26595 26620]
                                                      )
                                                    }
                                                  spids: [26594]
                                                )
                                              ]
                                              spids: [26594]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {
                                                            (DQ (X) 
                                                              ($ VSub_Name 
"$allow_libtool_libs_with_static_runtimes"
                                                              )
                                                            )
                                                          } {(Lit_Other "=")} {(DQ (Xyes))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (ForEach
                                                      iter_name: i
                                                      iter_words: [
                                                        {($ VSub_Name "$predeps")}
                                                        {($ VSub_Name "$postdeps")}
                                                      ]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:tmp_deplibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ ("X ") ($ VSub_Name "$tmp_deplibs"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      (${ VSub_Name 
SED
                                                                                      )
                                                                                    } {(-e)} {(DQ ("1s,^X,,"))} {(-e)} {(DQ ("s,") ($ VSub_Name "$i") (",,"))}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [26663 26690]
                                                                      )
                                                                    }
                                                                  spids: [26662]
                                                                )
                                                              ]
                                                              spids: [26662]
                                                            )
                                                          ]
                                                          spids: [26655 26693]
                                                        )
                                                      spids: [26648 26653]
                                                    )
                                                  ]
                                                  spids: [-1 26640]
                                                )
                                              ]
                                              spids: [-1 26696]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (Pipeline
                                                          children: [
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ ("X ") 
                                                                  ($ VSub_Name "$tmp_deplibs")
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                              {(SQ <"s/[ \t]//g">)}
                                                            )
                                                            (SimpleCommand
                                                              words: [{(grep)} {(.)}]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_Great
                                                                  fd: -1
                                                                  arg_word: {(/dev/null)}
                                                                  spids: [26726]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          negated: False
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$echo")})
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ (X) 
                                                                      ($ VSub_Name 
"$deplibs_check_method"
                                                                      )
                                                                    )
                                                                  } {(Lit_Other "=")} {(DQ (Xnone))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** Warning: inter-library dependencies are not supported in this platform."
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 26752]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** Warning: inter-library dependencies are not known to be supported."
                                                              )
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      spids: [26762 26772]
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** All declared inter-library dependencies are being dropped."
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:droppeddeps)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                          spids: [26782]
                                                        )
                                                      ]
                                                      spids: [26782]
                                                    )
                                                  ]
                                                  spids: [-1 26730]
                                                )
                                              ]
                                              spids: [-1 26786]
                                            )
                                          ]
                                          spids: [26577 26586 26789 -1]
                                        )
                                      ]
                                      spids: [24712 24716 26792]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:versuffix)
                                          op: Equal
                                          rhs: {($ VSub_Name "$versuffix_save")}
                                          spids: [26795]
                                        )
                                      ]
                                      spids: [26795]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:major)
                                          op: Equal
                                          rhs: {($ VSub_Name "$major_save")}
                                          spids: [26799]
                                        )
                                      ]
                                      spids: [26799]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:release)
                                          op: Equal
                                          rhs: {($ VSub_Name "$release_save")}
                                          spids: [26803]
                                        )
                                      ]
                                      spids: [26803]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libname)
                                          op: Equal
                                          rhs: {($ VSub_Name "$libname_save")}
                                          spids: [26807]
                                        )
                                      ]
                                      spids: [26807]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:name)
                                          op: Equal
                                          rhs: {($ VSub_Name "$name_save")}
                                          spids: [26811]
                                        )
                                      ]
                                      spids: [26811]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-rhapsody) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-darwin1.) 
                                              (Lit_Other "[") (012) (Lit_Other "]")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:newdeplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ ("X ") 
                                                                        ($ VSub_Name "$newdeplibs")
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {
                                                                      (SQ 
                                                                        <
"s/ -lc / -framework System /"
                                                                        >
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [26846 26863]
                                                      )
                                                    }
                                                  spids: [26845]
                                                )
                                              ]
                                              spids: [26845]
                                            )
                                          ]
                                          spids: [26823 26838 26866 -1]
                                        )
                                      ]
                                      spids: [26816 26820 26869]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$droppeddeps"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$module"))} 
                                                          {(Lit_Other "=")} {(yes)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$echo")})
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** Warning: libtool could not satisfy all declared inter-library"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ ("*** dependencies of module ") 
                                                          ($ VSub_Name "$libname") (".  Therefore, libtool will create")
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** a static module, that should work as long as the dlopening"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$echo")} 
                                                      {
                                                        (DQ 
                                                          (
"*** application is linked with the -dlopen flag."
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$global_symbol_pipe"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$echo")})
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** However, this would only work if libtool was able to extract symbol"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** lists from a program, using "
                                                                  ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("nm' or equivalent, but libtool could")
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ 
                                                                  (
"*** not find such a program.  So, this module is probably useless."
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$echo")} 
                                                              {
                                                                (DQ ("*** ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\`">
                                                                  ) ("nm' from GNU binutils and a full rebuild may help.")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 26949]
                                                        )
                                                      ]
                                                      spids: [-1 26987]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$build_old_libs")
                                                                    )
                                                                  } {(Lit_Other "=")} {(no)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:oldlibs)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$libname") (.) ($ VSub_Name "$libext")
                                                                      )
                                                                    }
                                                                  spids: [27006]
                                                                )
                                                              ]
                                                              spids: [27006]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: build_libtool_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(module)}
                                                                  spids: [27016]
                                                                )
                                                              ]
                                                              spids: [27016]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:build_old_libs)
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                  spids: [27020]
                                                                )
                                                              ]
                                                              spids: [27020]
                                                            )
                                                          ]
                                                          spids: [-1 27003]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:build_libtool_libs)
                                                              op: Equal
                                                              rhs: {(no)}
                                                              spids: [27027]
                                                            )
                                                          ]
                                                          spids: [27027]
                                                        )
                                                      ]
                                                      spids: [27024 27031]
                                                    )
                                                  ]
                                                  spids: [-1 26902]
                                                )
                                              ]
                                              else_action: [
                                                (C {($ VSub_Name "$echo")} 
                                                  {
                                                    (DQ 
                                                      (
"*** The inter-library dependencies that have been dropped here will be"
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {($ VSub_Name "$echo")} 
                                                  {
                                                    (DQ 
                                                      (
"*** automatically added whenever a program is linked with this library"
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {($ VSub_Name "$echo")} 
                                                  {(DQ ("*** or is declared to -dlopen it."))}
                                                )
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (Sentence
                                                          child: 
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$allow_undefined"))} {(Lit_Other "=")} {(no)}
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      action: [
                                                        (C {($ VSub_Name "$echo")})
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** Since this library must not contain undefined symbols,"
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** because either the platform does not support them or"
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** it was explicitly requested with -no-undefined,"
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$echo")} 
                                                          {
                                                            (DQ 
                                                              (
"*** libtool will only create a static version of it."
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (Sentence
                                                                  child: 
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$build_old_libs"
                                                                          )
                                                                        )
                                                                      } {(Lit_Other "=")} {(no)}
                                                                    )
                                                                  terminator: <Op_Semi ";">
                                                                )
                                                              ]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:oldlibs)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$output_objdir"
                                                                            ) (/) ($ VSub_Name "$libname") (.) ($ VSub_Name "$libext")
                                                                          )
                                                                        }
                                                                      spids: [27122]
                                                                    )
                                                                  ]
                                                                  spids: [27122]
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: build_libtool_libs
                                                                        )
                                                                      op: Equal
                                                                      rhs: {(module)}
                                                                      spids: [27132]
                                                                    )
                                                                  ]
                                                                  spids: [27132]
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: build_old_libs
                                                                        )
                                                                      op: Equal
                                                                      rhs: {(yes)}
                                                                      spids: [27136]
                                                                    )
                                                                  ]
                                                                  spids: [27136]
                                                                )
                                                              ]
                                                              spids: [-1 27119]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: build_libtool_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(no)}
                                                                  spids: [27143]
                                                                )
                                                              ]
                                                              spids: [27143]
                                                            )
                                                          ]
                                                          spids: [27140 27147]
                                                        )
                                                      ]
                                                      spids: [-1 27072]
                                                    )
                                                  ]
                                                  spids: [-1 27150]
                                                )
                                              ]
                                              spids: [27034 27153]
                                            )
                                          ]
                                          spids: [-1 26886]
                                        )
                                      ]
                                      spids: [-1 27156]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: {($ VSub_Name "$newdeplibs")}
                                          spids: [27163]
                                        )
                                      ]
                                      spids: [27163]
                                    )
                                  ]
                                  spids: [-1 24397]
                                )
                              ]
                              spids: [-1 27167]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:new_libs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [27180]
                                )
                              ]
                              spids: [27180]
                            )
                            (ForEach
                              iter_name: path
                              iter_words: [{($ VSub_Name "$notinst_path")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ (" ") ($ VSub_Name "$new_libs") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") 
                                              (DQ (" -L") ($ VSub_Name "$path") (/) 
                                                ($ VSub_Name "$objdir") (" ")
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          spids: [27206 27215 27217 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Case
                                              to_match: {(DQ (" ") ($ VSub_Name "$deplibs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" -L") ($ VSub_Name "$path") (/) 
                                                        ($ VSub_Name "$objdir") (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:new_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$new_libs") (" -L") 
                                                                ($ VSub_Name "$path") (/) ($ VSub_Name "$objdir")
                                                              )
                                                            }
                                                          spids: [27247]
                                                        )
                                                      ]
                                                      spids: [27247]
                                                    )
                                                  ]
                                                  spids: [27235 27244 27256 -1]
                                                )
                                              ]
                                              spids: [27224 27232 27259]
                                            )
                                          ]
                                          spids: [27220 27221 27262 -1]
                                        )
                                      ]
                                      spids: [27195 27203 27265]
                                    )
                                  ]
                                  spids: [27192 27268]
                                )
                              spids: [27188 27190]
                            )
                            (ForEach
                              iter_name: deplib
                              iter_words: [{($ VSub_Name "$deplibs")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {($ VSub_Name "$deplib")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-L) (Lit_Other "*")}]
                                          action: [
                                            (Case
                                              to_match: {(DQ (" ") ($ VSub_Name "$new_libs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$deplib") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [27306 27313 27315 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:new_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$new_libs") (" ") 
                                                                ($ VSub_Name "$deplib")
                                                              )
                                                            }
                                                          spids: [27321]
                                                        )
                                                      ]
                                                      spids: [27321]
                                                    )
                                                  ]
                                                  spids: [27318 27319 27328 -1]
                                                )
                                              ]
                                              spids: [27295 27303 27331]
                                            )
                                          ]
                                          spids: [27290 27292 27334 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:new_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$new_libs") (" ") 
                                                        ($ VSub_Name "$deplib")
                                                      )
                                                    }
                                                  spids: [27340]
                                                )
                                              ]
                                              spids: [27340]
                                            )
                                          ]
                                          spids: [27337 27338 27347 -1]
                                        )
                                      ]
                                      spids: [27283 27287 27350]
                                    )
                                  ]
                                  spids: [27280 27353]
                                )
                              spids: [27276 27278]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:deplibs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$new_libs"))}
                                  spids: [27356]
                                )
                              ]
                              spids: [27356]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:library_names)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [27368]
                                )
                              ]
                              spids: [27368]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:old_library)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [27371]
                                )
                              ]
                              spids: [27371]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlname)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [27374]
                                )
                              ]
                              spids: [27374]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                          {(Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$hardcode_into_libs"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:hardcode_libdirs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [27418]
                                                )
                                              ]
                                              spids: [27418]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dep_rpath)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [27421]
                                                )
                                              ]
                                              spids: [27421]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:rpath)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$finalize_rpath"))}
                                                  spids: [27424]
                                                )
                                              ]
                                              spids: [27424]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                  {(KW_Bang "!") (Lit_Other "=")} {(relink)}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:rpath)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$compile_rpath") 
                                                            ($ VSub_Name "$rpath")
                                                          )
                                                        }
                                                      spids: [27443]
                                                    )
                                                  ]
                                                  spids: [27443]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (ForEach
                                              iter_name: libdir
                                              iter_words: [{($ VSub_Name "$rpath")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_libdir_flag_spec"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-z)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$hardcode_libdirs"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
hardcode_libdirs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ VSub_Name 
"$libdir"
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  spids: [27504]
                                                                                )
                                                                              ]
                                                                              spids: [27504]
                                                                            )
                                                                          ]
                                                                          spids: [-1 27501]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (Case
                                                                          to_match: 
                                                                            {
                                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                              ) ($ VSub_Name "$hardcode_libdirs") ($ VSub_Name "$hardcode_libdir_separator")
                                                                            }
                                                                          arms: [
                                                                            (case_arm
                                                                              pat_list: [
                                                                                {(Lit_Other "*") 
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                                    ) ($ VSub_Name "$libdir") ($ VSub_Name "$hardcode_libdir_separator")
                                                                                  ) (Lit_Other "*")
                                                                                }
                                                                              ]
                                                                              spids: [
27526
27533
27536
-1
                                                                              ]
                                                                            )
                                                                            (case_arm
                                                                              pat_list: [
                                                                                {(Lit_Other "*")}
                                                                              ]
                                                                              action: [
                                                                                (Assignment
                                                                                  keyword: 
Assign_None
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (LhsName
                                                                                          name: 
hardcode_libdirs
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (DQ 
                                                                                            ($ 
VSub_Name "$hardcode_libdirs"
                                                                                            ) ($ VSub_Name "$hardcode_libdir_separator") ($ VSub_Name "$libdir")
                                                                                          )
                                                                                        }
                                                                                      spids: [27543]
                                                                                    )
                                                                                  ]
                                                                                  spids: [27543]
                                                                                )
                                                                              ]
                                                                              spids: [
27539
27540
27551
-1
                                                                              ]
                                                                            )
                                                                          ]
                                                                          spids: [27517 27523 27554]
                                                                        )
                                                                      ]
                                                                      spids: [27510 27557]
                                                                    )
                                                                  ]
                                                                  spids: [-1 27487]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {(eval)} 
                                                                  {(Lit_VarLike "flag=") 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar "\\\"">
                                                                    ) ($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                  }
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:dep_rpath)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$dep_rpath") (" ") ($ VSub_Name "$flag")
                                                                          )
                                                                        }
                                                                      spids: [27571]
                                                                    )
                                                                  ]
                                                                  spids: [27571]
                                                                )
                                                              ]
                                                              spids: [27560 27579]
                                                            )
                                                          ]
                                                          spids: [-1 27473]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$runpath_var"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_Name "$perm_rpath") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") 
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$libdir") (" ")
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [27606 27613 27615 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: perm_rpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$perm_rpath"
                                                                                ) (" ") ($ VSub_Name "$libdir")
                                                                              )
                                                                            }
                                                                          spids: [27621]
                                                                        )
                                                                      ]
                                                                      spids: [27621]
                                                                    )
                                                                  ]
                                                                  spids: [27618 27619 27628 -1]
                                                                )
                                                              ]
                                                              spids: [27596 27603 27631]
                                                            )
                                                          ]
                                                          spids: [27582 27593]
                                                        )
                                                      ]
                                                      spids: [-1 27634]
                                                    )
                                                  ]
                                                  spids: [27459 27637]
                                                )
                                              spids: [27455 27457]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ ($ VSub_Name "$hardcode_libdirs"))
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libdir)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$hardcode_libdirs"))}
                                                          spids: [27669]
                                                        )
                                                      ]
                                                      spids: [27669]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_libdir_flag_spec_ld"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "dep_rpath=") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$hardcode_libdir_flag_spec_ld") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 27686]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(eval)} 
                                                          {(Lit_VarLike "dep_rpath=") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            ) ($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                          }
                                                        )
                                                      ]
                                                      spids: [27697 27708]
                                                    )
                                                  ]
                                                  spids: [-1 27666]
                                                )
                                              ]
                                              spids: [-1 27711]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$runpath_var"))}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$perm_rpath"))}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rpath)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [27742]
                                                        )
                                                      ]
                                                      spids: [27742]
                                                    )
                                                    (ForEach
                                                      iter_name: dir
                                                      iter_words: [{($ VSub_Name "$perm_rpath")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:rpath)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$rpath") 
                                                                        ($ VSub_Name "$dir") (":")
                                                                      )
                                                                    }
                                                                  spids: [27757]
                                                                )
                                                              ]
                                                              spids: [27757]
                                                            )
                                                          ]
                                                          spids: [27754 27765]
                                                        )
                                                      spids: [27750 27752]
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ ($ VSub_Name "$runpath_var") ("='") 
                                                          ($ VSub_Name "$rpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$runpath_var") ("'; export ") 
                                                          ($ VSub_Name "$runpath_var")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [-1 27735]
                                                )
                                              ]
                                              spids: [-1 27781]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dep_rpath"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$dep_rpath") (" ") 
                                                            ($ VSub_Name "$deplibs")
                                                          )
                                                        }
                                                      spids: [27794]
                                                    )
                                                  ]
                                                  spids: [27794]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          spids: [-1 27411]
                                        )
                                      ]
                                      spids: [-1 27802]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:shlibpath)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$finalize_shlibpath"))}
                                          spids: [27806]
                                        )
                                      ]
                                      spids: [27806]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(relink)}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:shlibpath)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$compile_shlibpath") 
                                                    ($ VSub_Name "$shlibpath")
                                                  )
                                                }
                                              spids: [27825]
                                            )
                                          ]
                                          spids: [27825]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {
                                                (DQ ($ VSub_Name "$shlibpath_var") ("='") 
                                                  ($ VSub_Name "$shlibpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$shlibpath_var") ("'; export ") 
                                                  ($ VSub_Name "$shlibpath_var")
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 27843]
                                        )
                                      ]
                                      spids: [-1 27859]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "shared_ext=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$shrext_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "library_names=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$library_names_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (C {(set)} {(dummy)} {($ VSub_Name "$library_names")})
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:realname)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number "$2"))}
                                          spids: [27890]
                                        )
                                      ]
                                      spids: [27890]
                                    )
                                    (Sentence
                                      child: (C {(shift)})
                                      terminator: <Op_Semi ";">
                                    )
                                    (C {(shift)})
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$soname_spec"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "soname=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$soname_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                          ]
                                          spids: [-1 27914]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:soname)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$realname"))}
                                              spids: [27928]
                                            )
                                          ]
                                          spids: [27928]
                                        )
                                      ]
                                      spids: [27925 27934]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$dlname"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlname)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$soname")}
                                                  spids: [27951]
                                                )
                                              ]
                                              spids: [27951]
                                            )
                                          ]
                                          spids: [-1 27948]
                                        )
                                      ]
                                      spids: [-1 27955]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lib)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                ($ VSub_Name "$realname")
                                              )
                                            }
                                          spids: [27959]
                                        )
                                      ]
                                      spids: [27959]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:linknames)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [27967]
                                        )
                                      ]
                                      spids: [27967]
                                    )
                                    (ForEach
                                      iter_name: link
                                      do_arg_iter: True
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linknames)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$linknames") (" ") 
                                                        ($ VSub_Name "$link")
                                                      )
                                                    }
                                                  spids: [27978]
                                                )
                                              ]
                                              spids: [27978]
                                            )
                                          ]
                                          spids: [27975 27986]
                                        )
                                      spids: [-1 -1]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$pic_flag"))})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:libobjs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {(DQ (X) ($ VSub_Name "$libobjs"))}
                                                              )
                                                              (C {($ VSub_Name "$SP2NL")})
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {(DQ ($ VSub_Name "$lo2o"))}
                                                              )
                                                              (C {($ VSub_Name "$NL2SP")})
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [28005 28030]
                                                  )
                                                }
                                              spids: [28004]
                                            )
                                          ]
                                          spids: [28004]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$export_symbols"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name 
"$always_export_symbols"
                                                                  )
                                                                )
                                                              } {(Lit_Other "=")} {(yes)}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name 
"$export_symbols_regex"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ("generating symbol list for ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\`">
                                                          ) ($ VSub_Name "$libname") (".la'")
                                                        )
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:export_symbols)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$libname") (.exp)
                                                              )
                                                            }
                                                          spids: [28088]
                                                        )
                                                      ]
                                                      spids: [28088]
                                                    )
                                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                                      {($ VSub_Name "$export_symbols")}
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:cmds)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$export_symbols_cmds")}
                                                          spids: [28104]
                                                        )
                                                      ]
                                                      spids: [28104]
                                                    )
                                                    (Sentence
                                                      child: 
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:save_ifs)
                                                              op: Equal
                                                              rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                              spids: [28108]
                                                            )
                                                          ]
                                                          spids: [28108]
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(SQ <"~">)}
                                                          spids: [28114]
                                                        )
                                                      ]
                                                      spids: [28114]
                                                    )
                                                    (ForEach
                                                      iter_name: cmd
                                                      iter_words: [{($ VSub_Name "$cmds")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:IFS)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                                  spids: [28132]
                                                                )
                                                              ]
                                                              spids: [28132]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "cmd=") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              }
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (AndOr
                                                                          children: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: len
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (C 
                                                                                                {
                                                                                                  (
expr
                                                                                                  )
                                                                                                } {(DQ (X) ($ VSub_Name "$cmd"))} {(Lit_Other ":")} {(DQ (".*"))}
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
28149
28162
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [28148]
                                                                                )
                                                                              ]
                                                                              spids: [28148]
                                                                            )
                                                                            (AndOr
                                                                              children: [
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$len"
                                                                                      )
                                                                                    )
                                                                                  } {(-le)} {(DQ ($ VSub_Name "$max_cmd_len"))}
                                                                                )
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$max_cmd_len"
                                                                                      )
                                                                                    )
                                                                                  } {(-le)} {(-1)}
                                                                                )
                                                                              ]
                                                                              op_id: Op_DPipe
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_Name "$show")} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (AndOr
                                                                      children: [
                                                                        (C {($ VSub_Name "$run")} 
                                                                          {(eval)} {(DQ ($ VSub_Name "$cmd"))}
                                                                        )
                                                                        (C {(exit)} 
                                                                          {($ VSub_QMark "$?")}
                                                                        )
                                                                      ]
                                                                      op_id: Op_DPipe
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: skipped_export
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(false)}
                                                                          spids: [28217]
                                                                        )
                                                                      ]
                                                                      spids: [28217]
                                                                    )
                                                                  ]
                                                                  spids: [-1 28192]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {($ VSub_Name "$show")} 
                                                                  {
                                                                    (DQ 
                                                                      (
"using reloadable object file for export list..."
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: skipped_export
                                                                        )
                                                                      op: Equal
                                                                      rhs: {(Lit_Other ":")}
                                                                      spids: [28235]
                                                                    )
                                                                  ]
                                                                  spids: [28235]
                                                                )
                                                                (ControlFlow
                                                                  token: <ControlFlow_Break break>
                                                                )
                                                              ]
                                                              spids: [28221 28250]
                                                            )
                                                          ]
                                                          spids: [28129 28253]
                                                        )
                                                      spids: [28125 28127]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                          spids: [28256]
                                                        )
                                                      ]
                                                      spids: [28256]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$export_symbols_regex"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$show")} 
                                                              {
                                                                (DQ ($ VSub_Name "$EGREP") (" -e ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\"">
                                                                  ) ($ VSub_Name "$export_symbols_regex") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\"">
                                                                  ) ($ VSub_Name "$export_symbols") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" > ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\"">
                                                                  ) (${ VSub_Name export_symbols) (T) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
"$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
                                                                  >
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$show")} 
                                                              {
                                                                (DQ ($ VSub_Name "$mv") (" ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\"">
                                                                  ) (${ VSub_Name export_symbols) (T) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\"">
                                                                  ) ($ VSub_Name "$export_symbols") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
"$mv \"${export_symbols}T\" \"$export_symbols\""
                                                                  >
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 28273]
                                                        )
                                                      ]
                                                      spids: [-1 28334]
                                                    )
                                                  ]
                                                  spids: [-1 28075]
                                                )
                                              ]
                                              spids: [-1 28337]
                                            )
                                          ]
                                          spids: [-1 28049]
                                        )
                                      ]
                                      spids: [-1 28340]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$export_symbols"))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$include_expsyms"))}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$run")} {(eval)} 
                                              {
                                                (SQ 
                                                  <
"$echo \"X$include_expsyms\" | $SP2NL >> \"$export_symbols\""
                                                  >
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 28365]
                                        )
                                      ]
                                      spids: [-1 28377]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:tmp_deplibs)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [28381]
                                        )
                                      ]
                                      spids: [28381]
                                    )
                                    (ForEach
                                      iter_name: test_deplib
                                      iter_words: [{($ VSub_Name "$deplibs")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Case
                                              to_match: {(DQ (" ") ($ VSub_Name "$convenience") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$test_deplib") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [28407 28414 28416 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tmp_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$tmp_deplibs") (" ") 
                                                                ($ VSub_Name "$test_deplib")
                                                              )
                                                            }
                                                          spids: [28423]
                                                        )
                                                      ]
                                                      spids: [28423]
                                                    )
                                                  ]
                                                  spids: [28419 28420 28431 -1]
                                                )
                                              ]
                                              spids: [28396 28404 28434]
                                            )
                                          ]
                                          spids: [28393 28437]
                                        )
                                      spids: [28389 28391]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:deplibs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$tmp_deplibs"))}
                                          spids: [28440]
                                        )
                                      ]
                                      spids: [28440]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$convenience"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name "$whole_archive_flag_spec")
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:save_libobjs)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$libobjs")}
                                                          spids: [28475]
                                                        )
                                                      ]
                                                      spids: [28475]
                                                    )
                                                    (C {(eval)} 
                                                      {(Lit_VarLike "libobjs=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (libobjs)
                                                      } {($ VSub_Name "$whole_archive_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                                    )
                                                  ]
                                                  spids: [-1 28472]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:gentop)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$output_objdir") (/) 
                                                            (${ VSub_Name outputname) (x)
                                                          )
                                                        }
                                                      spids: [28493]
                                                    )
                                                  ]
                                                  spids: [28493]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:generated)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$generated") (" ") 
                                                            ($ VSub_Name "$gentop")
                                                          )
                                                        }
                                                      spids: [28504]
                                                    )
                                                  ]
                                                  spids: [28504]
                                                )
                                                (C {(func_extract_archives)} {($ VSub_Name "$gentop")} 
                                                  {($ VSub_Name "$convenience")}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:libobjs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$libobjs") (" ") 
                                                            ($ VSub_Name 
"$func_extract_archives_result"
                                                            )
                                                          )
                                                        }
                                                      spids: [28520]
                                                    )
                                                  ]
                                                  spids: [28520]
                                                )
                                              ]
                                              spids: [28490 28528]
                                            )
                                          ]
                                          spids: [-1 28458]
                                        )
                                      ]
                                      spids: [-1 28531]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$thread_safe"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$thread_safe_flag_spec"))}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "flag=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$thread_safe_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:linker_flags)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$linker_flags") (" ") 
                                                        ($ VSub_Name "$flag")
                                                      )
                                                    }
                                                  spids: [28570]
                                                )
                                              ]
                                              spids: [28570]
                                            )
                                          ]
                                          spids: [-1 28559]
                                        )
                                      ]
                                      spids: [-1 28578]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                  {(Lit_Other "=")} {(relink)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (SQ 
                                                      <
"(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)"
                                                      >
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 28599]
                                        )
                                      ]
                                      spids: [-1 28617]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$module"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$module_cmds"))}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$export_symbols"))}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name "$module_expsym_cmds")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(eval)} 
                                                      {(Lit_VarLike "test_cmds=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$module_expsym_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:cmds)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$module_expsym_cmds")}
                                                          spids: [28684]
                                                        )
                                                      ]
                                                      spids: [28684]
                                                    )
                                                  ]
                                                  spids: [-1 28673]
                                                )
                                              ]
                                              else_action: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "test_cmds=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$module_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:cmds)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$module_cmds")}
                                                      spids: [28699]
                                                    )
                                                  ]
                                                  spids: [28699]
                                                )
                                              ]
                                              spids: [28688 28703]
                                            )
                                          ]
                                          spids: [-1 28649]
                                        )
                                      ]
                                      else_action: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$export_symbols"))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$archive_expsym_cmds"))}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "test_cmds=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$archive_expsym_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:cmds)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$archive_expsym_cmds")}
                                                      spids: [28741]
                                                    )
                                                  ]
                                                  spids: [28741]
                                                )
                                              ]
                                              spids: [-1 28730]
                                            )
                                          ]
                                          else_action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "test_cmds=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$archive_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$archive_cmds")}
                                                  spids: [28756]
                                                )
                                              ]
                                              spids: [28756]
                                            )
                                          ]
                                          spids: [28745 28760]
                                        )
                                      ]
                                      spids: [28706 28763]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} 
                                                      {(DQ (X) ($ VSub_Name "$skipped_export"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ ("X:"))}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:len)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (CommandSubPart
                                                                    command_list: 
                                                                      (CommandList
                                                                        children: [
                                                                          (SimpleCommand
                                                                            words: [
                                                                              {(expr)}
                                                                              {
                                                                                (DQ (X) 
                                                                                  ($ VSub_Name 
"$test_cmds"
                                                                                  )
                                                                                )
                                                                              }
                                                                              {(Lit_Other ":")}
                                                                              {(DQ (".*"))}
                                                                            ]
                                                                            redirects: [
                                                                              (Redir
                                                                                op_id: Redir_Great
                                                                                fd: 2
                                                                                arg_word: 
                                                                                  {(/dev/null)}
                                                                                spids: [28801]
                                                                              )
                                                                            ]
                                                                          )
                                                                        ]
                                                                      )
                                                                    left_token: <Left_Backtick "`">
                                                                    spids: [28787 28803]
                                                                  )
                                                                }
                                                              spids: [28786]
                                                            )
                                                          ]
                                                          spids: [28786]
                                                        )
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(DQ ($ VSub_Name "$len"))} 
                                                              {(-le)} {(DQ ($ VSub_Name "$max_cmd_len"))}
                                                            )
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$max_cmd_len"))} {(-le)} {(-1)}
                                                            )
                                                          ]
                                                          op_id: Op_DPipe
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 28833]
                                        )
                                      ]
                                      else_action: [
                                        (C {($ VSub_Name "$echo")} 
                                          {(DQ ("creating reloadable object files..."))}
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_Name "$convenience"))}
                                                        )
                                                        (C {(test)} {(-z)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name "$whole_archive_flag_spec")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:save_libobjs)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$libobjs")}
                                                      spids: [28910]
                                                    )
                                                  ]
                                                  spids: [28910]
                                                )
                                              ]
                                              spids: [-1 28907]
                                            )
                                          ]
                                          spids: [-1 28914]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:save_output)
                                              op: Equal
                                              rhs: {($ VSub_Name "$output")}
                                              spids: [28917]
                                            )
                                          ]
                                          spids: [28917]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:output_la)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {(DQ (X) ($ VSub_Name "$output"))}
                                                              )
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {(DQ ($ VSub_Name "$basename"))}
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [28922 28939]
                                                  )
                                                }
                                              spids: [28921]
                                            )
                                          ]
                                          spids: [28921]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:test_cmds)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [28951]
                                            )
                                          ]
                                          spids: [28951]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:concat_cmds)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [28954]
                                            )
                                          ]
                                          spids: [28954]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:objlist)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [28957]
                                            )
                                          ]
                                          spids: [28957]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:delfiles)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [28960]
                                            )
                                          ]
                                          spids: [28960]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:last_robj)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [28963]
                                            )
                                          ]
                                          spids: [28963]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:k)
                                              op: Equal
                                              rhs: {(1)}
                                              spids: [28966]
                                            )
                                          ]
                                          spids: [28966]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:output)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_Name "$output_objdir") (/) 
                                                  ($ VSub_Name "$output_la") (-) (${ VSub_Name k) (.) ($ VSub_Name "$objext")
                                                }
                                              spids: [28970]
                                            )
                                          ]
                                          spids: [28970]
                                        )
                                        (ForEach
                                          iter_name: obj
                                          iter_words: [{($ VSub_Name "$save_libobjs")}]
                                          do_arg_iter: False
                                          body: 
                                            (DoGroup
                                              children: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "test_cmds=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$reload_cmds")
                                                  } {($ VSub_Name "$objlist")} 
                                                  {($ VSub_Name "$last_robj") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    )
                                                  }
                                                )
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (Sentence
                                                          child: 
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} 
                                                                  {(DQ (X) ($ VSub_Name "$objlist"))} {(Lit_Other "=")} {(X)}
                                                                )
                                                                (BraceGroup
                                                                  children: [
                                                                    (Sentence
                                                                      child: 
                                                                        (AndOr
                                                                          children: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: len
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (CommandSubPart
                                                                                        command_list: 
                                                                                          (CommandList
                                                                                            children: [
                                                                                              (SimpleCommand
                                                                                                words: [
                                                                                                  {
                                                                                                    (
expr
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    (DQ 
                                                                                                      (
X
                                                                                                      ) ($ VSub_Name "$test_cmds")
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    (
Lit_Other ":"
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    (DQ 
                                                                                                      (
".*"
                                                                                                      )
                                                                                                    )
                                                                                                  }
                                                                                                ]
                                                                                                redirects: [
                                                                                                  (Redir
                                                                                                    op_id: 
Redir_Great
                                                                                                    fd: 
2
                                                                                                    arg_word: 
                                                                                                      {
                                                                                                        (
/dev/null
                                                                                                        )
                                                                                                      }
                                                                                                    spids: [
29043
                                                                                                    ]
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        left_token: 
                                                                                          <
Left_Backtick "`"
                                                                                          >
                                                                                        spids: [
29029
29045
                                                                                        ]
                                                                                      )
                                                                                    }
                                                                                  spids: [29028]
                                                                                )
                                                                              ]
                                                                              spids: [29028]
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_Name "$len")
                                                                                )
                                                                              } {(-le)} {(DQ ($ VSub_Name "$max_cmd_len"))}
                                                                            )
                                                                          ]
                                                                          op_id: Op_DAmp
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  spids: [29026]
                                                                )
                                                              ]
                                                              op_id: Op_DPipe
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:objlist)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$objlist") (" ") 
                                                                    ($ VSub_Name "$obj")
                                                                  )
                                                                }
                                                              spids: [29069]
                                                            )
                                                          ]
                                                          spids: [29069]
                                                        )
                                                      ]
                                                      spids: [-1 29066]
                                                    )
                                                  ]
                                                  else_action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$k"))} 
                                                                  {(-eq)} {(1)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "concat_cmds=") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) ($ VSub_Name "$reload_cmds")
                                                              } {($ VSub_Name "$objlist")} 
                                                              {($ VSub_Name "$last_robj") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 29102]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(eval)} 
                                                          {(Lit_VarLike "concat_cmds=") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (concat_cmds) (Lit_Tilde "~") 
                                                            ($ VSub_Name "$reload_cmds")
                                                          } {($ VSub_Name "$objlist")} 
                                                          {($ VSub_Name "$last_robj") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      spids: [29121 29147]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:last_robj)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_Name "$output_objdir") (/) 
                                                              ($ VSub_Name "$output_la") (-) (${ VSub_Name k) (.) ($ VSub_Name "$objext")
                                                            }
                                                          spids: [29150]
                                                        )
                                                      ]
                                                      spids: [29150]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:k)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (C {(expr)} {($ VSub_Name "$k")} 
                                                                        {(Lit_Other "+")} {(1)}
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [29163 29171]
                                                              )
                                                            }
                                                          spids: [29162]
                                                        )
                                                      ]
                                                      spids: [29162]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:output)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_Name "$output_objdir") (/) 
                                                              ($ VSub_Name "$output_la") (-) (${ VSub_Name k) (.) ($ VSub_Name "$objext")
                                                            }
                                                          spids: [29174]
                                                        )
                                                      ]
                                                      spids: [29174]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:objlist)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$obj")}
                                                          spids: [29186]
                                                        )
                                                      ]
                                                      spids: [29186]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:len)
                                                          op: Equal
                                                          rhs: {(1)}
                                                          spids: [29190]
                                                        )
                                                      ]
                                                      spids: [29190]
                                                    )
                                                  ]
                                                  spids: [29077 29194]
                                                )
                                              ]
                                              spids: [28995 29197]
                                            )
                                          spids: [28991 -1]
                                        )
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$concat_cmds"))})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:concat_cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$concat_cmds") (Lit_Tilde "~")}
                                                  spids: [29222]
                                                )
                                              ]
                                              spids: [29222]
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                        (C {(eval)} 
                                          {(Lit_VarLike "concat_cmds=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (Lit_LBrace "{") (concat_cmds) (Lit_RBrace "}") 
                                            ($ VSub_Name "$reload_cmds")
                                          } {($ VSub_Name "$objlist")} 
                                          {($ VSub_Name "$last_robj") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            )
                                          }
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C 
                                                      {
                                                        (BracedVarSub
                                                          token: <VSub_Name skipped_export>
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VTest_Hyphen
                                                              arg_word: {(false)}
                                                            )
                                                          spids: [29246 29250]
                                                        )
                                                      }
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (C {($ VSub_Name "$show")} 
                                                  {
                                                    (DQ ("generating symbol list for ") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\`">
                                                      ) ($ VSub_Name "$libname") (".la'")
                                                    )
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:export_symbols)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$output_objdir") (/) 
                                                            ($ VSub_Name "$libname") (.exp)
                                                          )
                                                        }
                                                      spids: [29266]
                                                    )
                                                  ]
                                                  spids: [29266]
                                                )
                                                (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                                  {($ VSub_Name "$export_symbols")}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:libobjs)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$output")}
                                                      spids: [29282]
                                                    )
                                                  ]
                                                  spids: [29282]
                                                )
                                                (C {(eval)} 
                                                  {(Lit_VarLike "concat_cmds=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (concat_cmds) (Lit_Tilde "~") 
                                                    ($ VSub_Name "$export_symbols_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                              ]
                                              spids: [-1 29253]
                                            )
                                          ]
                                          spids: [-1 29301]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:i)
                                              op: Equal
                                              rhs: {(0)}
                                              spids: [29313]
                                            )
                                          ]
                                          spids: [29313]
                                        )
                                        (While
                                          cond: [
                                            (C {(test)} {(DQ ($ VSub_Name "$i"))} {(-lt)} 
                                              {(DQ ($ VSub_Name "$k"))}
                                            )
                                          ]
                                          body: 
                                            (DoGroup
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:i)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} {($ VSub_Name "$i")} 
                                                                    {(Lit_Other "+")} {(1)}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [29336 29344]
                                                          )
                                                        }
                                                      spids: [29335]
                                                    )
                                                  ]
                                                  spids: [29335]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:delfiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$delfiles") (" ") 
                                                            ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$output_la") (-) (${ VSub_Name i) (.) ($ VSub_Name "$objext")
                                                          )
                                                        }
                                                      spids: [29347]
                                                    )
                                                  ]
                                                  spids: [29347]
                                                )
                                              ]
                                              spids: [29332 29363]
                                            )
                                        )
                                        (C {($ VSub_Name "$echo")} 
                                          {
                                            (DQ ("creating a temporary reloadable object file: ") 
                                              ($ VSub_Name "$output")
                                            )
                                          }
                                        )
                                        (Sentence
                                          child: 
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:save_ifs)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                  spids: [29380]
                                                )
                                              ]
                                              spids: [29380]
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:IFS)
                                              op: Equal
                                              rhs: {(SQ <"~">)}
                                              spids: [29386]
                                            )
                                          ]
                                          spids: [29386]
                                        )
                                        (ForEach
                                          iter_name: cmd
                                          iter_words: [{($ VSub_Name "$concat_cmds")}]
                                          do_arg_iter: False
                                          body: 
                                            (DoGroup
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:IFS)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                      spids: [29404]
                                                    )
                                                  ]
                                                  spids: [29404]
                                                )
                                                (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                                (AndOr
                                                  children: [
                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                    )
                                                    (C {(exit)} {($ VSub_QMark "$?")})
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              ]
                                              spids: [29401 29432]
                                            )
                                          spids: [29397 29399]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:IFS)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                              spids: [29435]
                                            )
                                          ]
                                          spids: [29435]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:libobjs)
                                              op: Equal
                                              rhs: {($ VSub_Name "$output")}
                                              spids: [29442]
                                            )
                                          ]
                                          spids: [29442]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:output)
                                              op: Equal
                                              rhs: {($ VSub_Name "$save_output")}
                                              spids: [29450]
                                            )
                                          ]
                                          spids: [29450]
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$convenience"))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name "$whole_archive_flag_spec")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "libobjs=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (libobjs)
                                                  } {($ VSub_Name "$whole_archive_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                                )
                                              ]
                                              spids: [-1 29476]
                                            )
                                          ]
                                          spids: [-1 29490]
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ ($ VSub_Name "$module"))} 
                                                          {(Lit_Other "=")} {(yes)}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$module_cmds"))}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (Sentence
                                                          child: 
                                                            (AndOr
                                                              children: [
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$export_symbols")
                                                                    )
                                                                  }
                                                                )
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$module_expsym_cmds"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                              op_id: Op_DAmp
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:cmds)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_Name "$module_expsym_cmds")
                                                                }
                                                              spids: [29557]
                                                            )
                                                          ]
                                                          spids: [29557]
                                                        )
                                                      ]
                                                      spids: [-1 29554]
                                                    )
                                                  ]
                                                  else_action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:cmds)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$module_cmds")}
                                                          spids: [29564]
                                                        )
                                                      ]
                                                      spids: [29564]
                                                    )
                                                  ]
                                                  spids: [29561 29568]
                                                )
                                              ]
                                              spids: [-1 29530]
                                            )
                                          ]
                                          else_action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$export_symbols"))}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name "$archive_expsym_cmds")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:cmds)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$archive_expsym_cmds")}
                                                          spids: [29598]
                                                        )
                                                      ]
                                                      spids: [29598]
                                                    )
                                                  ]
                                                  spids: [-1 29595]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:cmds)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$archive_cmds")}
                                                      spids: [29605]
                                                    )
                                                  ]
                                                  spids: [29605]
                                                )
                                              ]
                                              spids: [29602 29609]
                                            )
                                          ]
                                          spids: [29571 29612]
                                        )
                                        (C {(eval)} 
                                          {(Lit_VarLike "cmds=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (cmds) (Lit_Tilde "~") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (rm)
                                          } {($ VSub_Name "$delfiles") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                        )
                                      ]
                                      spids: [28839 29638]
                                    )
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:save_ifs)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$IFS"))}
                                              spids: [29641]
                                            )
                                          ]
                                          spids: [29641]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(SQ <"~">)}
                                          spids: [29647]
                                        )
                                      ]
                                      spids: [29647]
                                    )
                                    (ForEach
                                      iter_name: cmd
                                      iter_words: [{($ VSub_Name "$cmds")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [29665]
                                                )
                                              ]
                                              spids: [29665]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike "cmd=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {(DQ ($ VSub_Name "$cmd"))}
                                                )
                                                (BraceGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:lt_exit)
                                                          op: Equal
                                                          rhs: {($ VSub_QMark "$?")}
                                                          spids: [29699]
                                                        )
                                                      ]
                                                      spids: [29699]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                                  {(Lit_Other "=")} {(relink)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
"(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)"
                                                                  >
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 29721]
                                                        )
                                                      ]
                                                      spids: [-1 29733]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$lt_exit")})
                                                  ]
                                                  spids: [29696]
                                                )
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [29662 29745]
                                        )
                                      spids: [29658 29660]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [29748]
                                        )
                                      ]
                                      spids: [29748]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                  {(Lit_Other "=")} {(relink)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (SQ 
                                                      <
"(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv \"$realname\"U $realname)"
                                                      >
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$convenience"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$whole_archive_flag_spec"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$show")} 
                                                              {
                                                                (DQ (${ VSub_Name rm) ("r ") 
                                                                  ($ VSub_Name "$gentop")
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} 
                                                              {(${ VSub_Name rm) (r)} {(DQ ($ VSub_Name "$gentop"))}
                                                            )
                                                          ]
                                                          spids: [-1 29816]
                                                        )
                                                      ]
                                                      spids: [-1 29842]
                                                    )
                                                  ]
                                                  spids: [-1 29802]
                                                )
                                              ]
                                              spids: [-1 29845]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                                          ]
                                          spids: [-1 29772]
                                        )
                                      ]
                                      spids: [-1 29854]
                                    )
                                    (ForEach
                                      iter_name: linkname
                                      iter_words: [{($ VSub_Name "$linknames")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$realname"))} 
                                                          {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$linkname"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ("(cd ") ($ VSub_Name "$output_objdir") 
                                                          (" && ") ($ VSub_Name "$rm") (" ") ($ VSub_Name "$linkname") (" && ") ($ VSub_Name "$LN_S") (" ") 
                                                          ($ VSub_Name "$realname") (" ") ($ VSub_Name "$linkname") (")")
                                                        )
                                                      }
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {
                                                            (SQ 
                                                              <
"(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
                                                              >
                                                            )
                                                          }
                                                        )
                                                        (C {(exit)} {($ VSub_QMark "$?")})
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  ]
                                                  spids: [-1 29890]
                                                )
                                              ]
                                              spids: [-1 29927]
                                            )
                                          ]
                                          spids: [29871 29930]
                                        )
                                      spids: [29867 29869]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$module"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                    (C {(test)} {(DQ ($ VSub_Name "$export_dynamic"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlname)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$soname"))}
                                                  spids: [29970]
                                                )
                                              ]
                                              spids: [29970]
                                            )
                                          ]
                                          spids: [-1 29963]
                                        )
                                      ]
                                      spids: [-1 29976]
                                    )
                                  ]
                                  spids: [-1 27395]
                                )
                              ]
                              spids: [-1 29979]
                            )
                          ]
                          spids: [21724 21725 29982 -1]
                        )
                        (case_arm
                          pat_list: [{(obj)}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$deplibs"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-l' and ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-L' are ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30015]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30001]
                                )
                              ]
                              spids: [-1 30019]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {
                                                (DQ ($ VSub_Name "$dlfiles") 
                                                  ($ VSub_Name "$dlprefiles")
                                                )
                                              }
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$dlself"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-dlopen' is ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30060]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30048]
                                )
                              ]
                              spids: [-1 30064]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$rpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-rpath' is ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30091]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30079]
                                )
                              ]
                              spids: [-1 30095]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$xrpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-R' is ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30122]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30110]
                                )
                              ]
                              spids: [-1 30126]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$vinfo"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-version-info' is ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30153]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30141]
                                )
                              ]
                              spids: [-1 30157]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$release"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-release' is ignored for objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30184]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30172]
                                )
                              ]
                              spids: [-1 30188]
                            )
                            (Case
                              to_match: {($ VSub_Name "$output")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.lo)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ ($ VSub_Name "$objs") 
                                                      ($ VSub_Name "$old_deplibs")
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": cannot build library object ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$output") 
                                                    ("' from non-libtool objects")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [30229]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [-1 30216]
                                        )
                                      ]
                                      spids: [-1 30238]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libobj)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$output"))}
                                          spids: [30241]
                                        )
                                      ]
                                      spids: [30241]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:obj)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$output"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$lo2o"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [30248 30265]
                                              )
                                            }
                                          spids: [30247]
                                        )
                                      ]
                                      spids: [30247]
                                    )
                                  ]
                                  spids: [30199 30201 30268 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libobj)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [30275]
                                        )
                                      ]
                                      spids: [30275]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:obj)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$output"))}
                                          spids: [30278]
                                        )
                                      ]
                                      spids: [30278]
                                    )
                                  ]
                                  spids: [30271 30272 30284 -1]
                                )
                              ]
                              spids: [30192 30196 30287]
                            )
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {($ VSub_Name "$obj")} 
                              {($ VSub_Name "$libobj")}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reload_conv_objs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [30321]
                                )
                              ]
                              spids: [30321]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:gentop)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [30324]
                                )
                              ]
                              spids: [30324]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:wl)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [30335]
                                )
                              ]
                              spids: [30335]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$convenience"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_Name "$whole_archive_flag_spec"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "reload_conv_objs=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (reload_objs)
                                              } {($ VSub_Name "$whole_archive_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                            )
                                          ]
                                          spids: [-1 30364]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:gentop)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$output_objdir") (/) 
                                                    (${ VSub_Name obj) (x)
                                                  )
                                                }
                                              spids: [30381]
                                            )
                                          ]
                                          spids: [30381]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:generated)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$generated") (" ") 
                                                    ($ VSub_Name "$gentop")
                                                  )
                                                }
                                              spids: [30392]
                                            )
                                          ]
                                          spids: [30392]
                                        )
                                        (C {(func_extract_archives)} {($ VSub_Name "$gentop")} 
                                          {($ VSub_Name "$convenience")}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:reload_conv_objs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$reload_objs") (" ") 
                                                    ($ VSub_Name "$func_extract_archives_result")
                                                  )
                                                }
                                              spids: [30408]
                                            )
                                          ]
                                          spids: [30408]
                                        )
                                      ]
                                      spids: [30378 30416]
                                    )
                                  ]
                                  spids: [-1 30350]
                                )
                              ]
                              spids: [-1 30419]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reload_objs)
                                  op: Equal
                                  rhs: 
                                    {(DQ ($ VSub_Name "$objs") ($ VSub_Name "$old_deplibs") (" ")) 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$libobjs"))}
                                                  )
                                                  (C {($ VSub_Name "$SP2NL")})
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(SQ <"/\\.">) (${ VSub_Name libext) (SQ </d>)} {(-e)} {(SQ <"/\\.lib$/d">)} {(-e)} {(DQ ($ VSub_Name "$lo2o"))}
                                                  )
                                                  (C {($ VSub_Name "$NL2SP")})
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [30433 30476]
                                      ) (DQ (" ") ($ VSub_Name "$reload_conv_objs"))
                                    }
                                  spids: [30427]
                                )
                              ]
                              spids: [30427]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:output)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$obj"))}
                                  spids: [30487]
                                )
                              ]
                              spids: [30487]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cmds)
                                  op: Equal
                                  rhs: {($ VSub_Name "$reload_cmds")}
                                  spids: [30493]
                                )
                              ]
                              spids: [30493]
                            )
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:save_ifs)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                      spids: [30497]
                                    )
                                  ]
                                  spids: [30497]
                                )
                              terminator: <Op_Semi ";">
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(SQ <"~">)}
                                  spids: [30503]
                                )
                              ]
                              spids: [30503]
                            )
                            (ForEach
                              iter_name: cmd
                              iter_words: [{($ VSub_Name "$cmds")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [30521]
                                        )
                                      ]
                                      spids: [30521]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "cmd=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} {(DQ ($ VSub_Name "$cmd"))})
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [30518 30557]
                                )
                              spids: [30514 30516]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                  spids: [30560]
                                )
                              ]
                              spids: [30560]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$libobj"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$gentop"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$show")} 
                                              {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$gentop"))}
                                            )
                                            (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} 
                                              {($ VSub_Name "$gentop")}
                                            )
                                          ]
                                          spids: [-1 30596]
                                        )
                                      ]
                                      spids: [-1 30620]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                                  ]
                                  spids: [-1 30582]
                                )
                              ]
                              spids: [-1 30629]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$gentop"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$show")} 
                                              {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$gentop"))}
                                            )
                                            (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} 
                                              {($ VSub_Name "$gentop")}
                                            )
                                          ]
                                          spids: [-1 30661]
                                        )
                                      ]
                                      spids: [-1 30685]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                                  ]
                                  spids: [-1 30647]
                                )
                              ]
                              spids: [-1 30710]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$pic_flag"))})
                                            (C {(test)} {(DQ ($ VSub_Name "$pic_mode"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(default)}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:reload_objs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$libobjs") (" ") 
                                                ($ VSub_Name "$reload_conv_objs")
                                              )
                                            }
                                          spids: [30745]
                                        )
                                      ]
                                      spids: [30745]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:output)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$libobj"))}
                                          spids: [30753]
                                        )
                                      ]
                                      spids: [30753]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:cmds)
                                          op: Equal
                                          rhs: {($ VSub_Name "$reload_cmds")}
                                          spids: [30759]
                                        )
                                      ]
                                      spids: [30759]
                                    )
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:save_ifs)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$IFS"))}
                                              spids: [30763]
                                            )
                                          ]
                                          spids: [30763]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(SQ <"~">)}
                                          spids: [30769]
                                        )
                                      ]
                                      spids: [30769]
                                    )
                                    (ForEach
                                      iter_name: cmd
                                      iter_words: [{($ VSub_Name "$cmds")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [30787]
                                                )
                                              ]
                                              spids: [30787]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike "cmd=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {(DQ ($ VSub_Name "$cmd"))}
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [30784 30823]
                                        )
                                      spids: [30780 30782]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [30826]
                                        )
                                      ]
                                      spids: [30826]
                                    )
                                  ]
                                  spids: [-1 30738]
                                )
                              ]
                              spids: [-1 30832]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$gentop"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} 
                                      {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$gentop"))}
                                    )
                                    (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} 
                                      {($ VSub_Name "$gentop")}
                                    )
                                  ]
                                  spids: [-1 30847]
                                )
                              ]
                              spids: [-1 30871]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                          ]
                          spids: [29986 29987 30880 -1]
                        )
                        (case_arm
                          pat_list: [{(prog)}]
                          action: [
                            (Case
                              to_match: {($ VSub_Name "$host")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (cygwin) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:output)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {($ VSub_Name "$output")}
                                                          )
                                                          (C {(${ VSub_Name SED)} {(-e)} 
                                                            {(SQ <"s,.exe$,,;s,$,.exe,">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [30901 30917]
                                              )
                                            }
                                          spids: [30900]
                                        )
                                      ]
                                      spids: [30900]
                                    )
                                  ]
                                  spids: [30895 30898 30919 -1]
                                )
                              ]
                              spids: [30888 30892 30922]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$vinfo"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-version-info' is ignored for programs")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30948]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30936]
                                )
                              ]
                              spids: [-1 30952]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$release"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-release' is ignored for programs")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [30979]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 30967]
                                )
                              ]
                              spids: [-1 30983]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$preload"))} {(Lit_Other "=")} 
                                          {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$dlopen_support"))} 
                                                      {(Lit_Other "=")} {(unknown)}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(DQ ($ VSub_Name "$dlopen_self"))} 
                                                          {(Lit_Other "=")} {(unknown)}
                                                        )
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_Name "$dlopen_self_static"))} {(Lit_Other "=")} {(unknown)}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$echo")} 
                                              {
                                                (DQ ($ VSub_Name "$modename") (": warning: ") 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\`">
                                                  ) ("AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support.")
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 31041]
                                        )
                                      ]
                                      spids: [-1 31054]
                                    )
                                  ]
                                  spids: [-1 31000]
                                )
                              ]
                              spids: [-1 31057]
                            )
                            (Case
                              to_match: {($ VSub_Name "$host")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (-) (Lit_Other "*") (-rhapsody) (Lit_Other "*")}
                                    {(Lit_Other "*") (-) (Lit_Other "*") (-darwin1.) (Lit_Other "[") 
                                      (012) (Lit_Other "]")
                                    }
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ ("X ") 
                                                                ($ VSub_Name "$compile_deplibs")
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/ -lc / -framework System /">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [31091 31108]
                                              )
                                            }
                                          spids: [31090]
                                        )
                                      ]
                                      spids: [31090]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ ("X ") 
                                                                ($ VSub_Name "$finalize_deplibs")
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s/ -lc / -framework System /">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [31112 31129]
                                              )
                                            }
                                          spids: [31111]
                                        )
                                      ]
                                      spids: [31111]
                                    )
                                  ]
                                  spids: [31068 31083 31132 -1]
                                )
                              ]
                              spids: [31061 31065 31135]
                            )
                            (Case
                              to_match: {($ VSub_Name "$host")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (darwin) (Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$tagname"))} 
                                                  {(Lit_Other "=")} {(CXX)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                                        (${ VSub_Name wl) (-bind_at_load)
                                                      )
                                                    }
                                                  spids: [31173]
                                                )
                                              ]
                                              spids: [31173]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                                        (${ VSub_Name wl) (-bind_at_load)
                                                      )
                                                    }
                                                  spids: [31184]
                                                )
                                              ]
                                              spids: [31184]
                                            )
                                          ]
                                          spids: [-1 31170]
                                        )
                                      ]
                                      spids: [-1 31195]
                                    )
                                  ]
                                  spids: [31146 31149 31198 -1]
                                )
                              ]
                              spids: [31139 31143 31201]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:new_libs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [31214]
                                )
                              ]
                              spids: [31214]
                            )
                            (ForEach
                              iter_name: path
                              iter_words: [{($ VSub_Name "$notinst_path")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ (" ") ($ VSub_Name "$new_libs") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") 
                                              (DQ (" -L") ($ VSub_Name "$path") (/) 
                                                ($ VSub_Name "$objdir") (" ")
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          spids: [31240 31249 31251 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Case
                                              to_match: 
                                                {(DQ (" ") ($ VSub_Name "$compile_deplibs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" -L") ($ VSub_Name "$path") (/) 
                                                        ($ VSub_Name "$objdir") (" ")
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:new_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$new_libs") (" -L") 
                                                                ($ VSub_Name "$path") (/) ($ VSub_Name "$objdir")
                                                              )
                                                            }
                                                          spids: [31281]
                                                        )
                                                      ]
                                                      spids: [31281]
                                                    )
                                                  ]
                                                  spids: [31269 31278 31290 -1]
                                                )
                                              ]
                                              spids: [31258 31266 31293]
                                            )
                                          ]
                                          spids: [31254 31255 31296 -1]
                                        )
                                      ]
                                      spids: [31229 31237 31299]
                                    )
                                  ]
                                  spids: [31226 31302]
                                )
                              spids: [31222 31224]
                            )
                            (ForEach
                              iter_name: deplib
                              iter_words: [{($ VSub_Name "$compile_deplibs")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {($ VSub_Name "$deplib")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-L) (Lit_Other "*")}]
                                          action: [
                                            (Case
                                              to_match: {(DQ (" ") ($ VSub_Name "$new_libs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$deplib") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [31340 31347 31349 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:new_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$new_libs") (" ") 
                                                                ($ VSub_Name "$deplib")
                                                              )
                                                            }
                                                          spids: [31355]
                                                        )
                                                      ]
                                                      spids: [31355]
                                                    )
                                                  ]
                                                  spids: [31352 31353 31362 -1]
                                                )
                                              ]
                                              spids: [31329 31337 31365]
                                            )
                                          ]
                                          spids: [31324 31326 31368 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:new_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$new_libs") (" ") 
                                                        ($ VSub_Name "$deplib")
                                                      )
                                                    }
                                                  spids: [31374]
                                                )
                                              ]
                                              spids: [31374]
                                            )
                                          ]
                                          spids: [31371 31372 31381 -1]
                                        )
                                      ]
                                      spids: [31317 31321 31384]
                                    )
                                  ]
                                  spids: [31314 31387]
                                )
                              spids: [31310 31312]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_deplibs)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$new_libs"))}
                                  spids: [31390]
                                )
                              ]
                              spids: [31390]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$compile_command") (" ") 
                                        ($ VSub_Name "$compile_deplibs")
                                      )
                                    }
                                  spids: [31398]
                                )
                              ]
                              spids: [31398]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:finalize_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$finalize_command") (" ") 
                                        ($ VSub_Name "$finalize_deplibs")
                                      )
                                    }
                                  spids: [31406]
                                )
                              ]
                              spids: [31406]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_Name "$rpath") ($ VSub_Name "$xrpath"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (ForEach
                                      iter_name: libdir
                                      iter_words: [{($ VSub_Name "$rpath")} {($ VSub_Name "$xrpath")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$finalize_rpath") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [31462 31469 31471 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$finalize_rpath") 
                                                                (" ") ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [31477]
                                                        )
                                                      ]
                                                      spids: [31477]
                                                    )
                                                  ]
                                                  spids: [31474 31475 31484 -1]
                                                )
                                              ]
                                              spids: [31452 31459 31487]
                                            )
                                          ]
                                          spids: [31445 31490]
                                        )
                                      spids: [31439 31443]
                                    )
                                  ]
                                  spids: [-1 31427]
                                )
                              ]
                              spids: [-1 31493]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:rpath)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [31501]
                                )
                              ]
                              spids: [31501]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:hardcode_libdirs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [31504]
                                )
                              ]
                              spids: [31504]
                            )
                            (ForEach
                              iter_name: libdir
                              iter_words: [
                                {($ VSub_Name "$compile_rpath")}
                                {($ VSub_Name "$finalize_rpath")}
                              ]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_Name "$hardcode_libdir_flag_spec"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_libdirs"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: hardcode_libdirs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$libdir"))}
                                                                  spids: [31563]
                                                                )
                                                              ]
                                                              spids: [31563]
                                                            )
                                                          ]
                                                          spids: [-1 31560]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Case
                                                          to_match: 
                                                            {
                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                              ) ($ VSub_Name "$hardcode_libdirs") ($ VSub_Name "$hardcode_libdir_separator")
                                                            }
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "*") 
                                                                  (DQ 
                                                                    ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                    ) ($ VSub_Name "$libdir") ($ VSub_Name "$hardcode_libdir_separator")
                                                                  ) (Lit_Other "*")
                                                                }
                                                              ]
                                                              spids: [31585 31592 31595 -1]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Other "*")}]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: hardcode_libdirs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$hardcode_libdirs"
                                                                            ) ($ VSub_Name "$hardcode_libdir_separator") ($ VSub_Name "$libdir")
                                                                          )
                                                                        }
                                                                      spids: [31602]
                                                                    )
                                                                  ]
                                                                  spids: [31602]
                                                                )
                                                              ]
                                                              spids: [31598 31599 31610 -1]
                                                            )
                                                          ]
                                                          spids: [31576 31582 31613]
                                                        )
                                                      ]
                                                      spids: [31569 31616]
                                                    )
                                                  ]
                                                  spids: [-1 31546]
                                                )
                                              ]
                                              else_action: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "flag=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:rpath)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$rpath") (" ") 
                                                            ($ VSub_Name "$flag")
                                                          )
                                                        }
                                                      spids: [31630]
                                                    )
                                                  ]
                                                  spids: [31630]
                                                )
                                              ]
                                              spids: [31619 31638]
                                            )
                                          ]
                                          spids: [-1 31532]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$runpath_var"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$perm_rpath") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [31665 31672 31674 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:perm_rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$perm_rpath") (" ") 
                                                                ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [31680]
                                                        )
                                                      ]
                                                      spids: [31680]
                                                    )
                                                  ]
                                                  spids: [31677 31678 31687 -1]
                                                )
                                              ]
                                              spids: [31655 31662 31690]
                                            )
                                          ]
                                          spids: [31641 31652]
                                        )
                                      ]
                                      spids: [-1 31693]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-cygwin) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-mingw) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-pw32) 
                                              (Lit_Other "*")
                                            }
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-os2) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:testbindir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) ($ VSub_Name "$libdir"))
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s*/lib$*/bin*">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [31736 31753]
                                                      )
                                                    }
                                                  spids: [31735]
                                                )
                                              ]
                                              spids: [31735]
                                            )
                                            (Case
                                              to_match: 
                                                {(Lit_Other ":") ($ VSub_Name "$dllsearchpath") 
                                                  (Lit_Other ":")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (":") ($ VSub_Name "$libdir") (":")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [31765 31772 31774 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dllsearchpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dllsearchpath") (":") 
                                                                ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [31780]
                                                        )
                                                      ]
                                                      spids: [31780]
                                                    )
                                                  ]
                                                  spids: [31777 31778 31786 -1]
                                                )
                                              ]
                                              spids: [31756 31762 31789]
                                            )
                                            (Case
                                              to_match: 
                                                {(Lit_Other ":") ($ VSub_Name "$dllsearchpath") 
                                                  (Lit_Other ":")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (":") ($ VSub_Name "$testbindir") (":")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [31801 31808 31810 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dllsearchpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$dllsearchpath") (":") 
                                                                ($ VSub_Name "$testbindir")
                                                              )
                                                            }
                                                          spids: [31816]
                                                        )
                                                      ]
                                                      spids: [31816]
                                                    )
                                                  ]
                                                  spids: [31813 31814 31822 -1]
                                                )
                                              ]
                                              spids: [31792 31798 31825]
                                            )
                                          ]
                                          spids: [31703 31732 31828 -1]
                                        )
                                      ]
                                      spids: [31696 31700 31831]
                                    )
                                  ]
                                  spids: [31518 31834]
                                )
                              spids: [31512 31516]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_Name "$hardcode_libdir_separator"))}
                                            )
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$hardcode_libdirs"))})
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libdir)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$hardcode_libdirs"))}
                                          spids: [31866]
                                        )
                                      ]
                                      spids: [31866]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "rpath=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        )
                                      } {($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                    )
                                  ]
                                  spids: [-1 31863]
                                )
                              ]
                              spids: [-1 31881]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_rpath)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$rpath"))}
                                  spids: [31884]
                                )
                              ]
                              spids: [31884]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:rpath)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [31891]
                                )
                              ]
                              spids: [31891]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:hardcode_libdirs)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [31894]
                                )
                              ]
                              spids: [31894]
                            )
                            (ForEach
                              iter_name: libdir
                              iter_words: [{($ VSub_Name "$finalize_rpath")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_Name "$hardcode_libdir_flag_spec"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$hardcode_libdirs"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: hardcode_libdirs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$libdir"))}
                                                                  spids: [31951]
                                                                )
                                                              ]
                                                              spids: [31951]
                                                            )
                                                          ]
                                                          spids: [-1 31948]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Case
                                                          to_match: 
                                                            {
                                                              ($ VSub_Name 
"$hardcode_libdir_separator"
                                                              ) ($ VSub_Name "$hardcode_libdirs") ($ VSub_Name "$hardcode_libdir_separator")
                                                            }
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "*") 
                                                                  (DQ 
                                                                    ($ VSub_Name 
"$hardcode_libdir_separator"
                                                                    ) ($ VSub_Name "$libdir") ($ VSub_Name "$hardcode_libdir_separator")
                                                                  ) (Lit_Other "*")
                                                                }
                                                              ]
                                                              spids: [31973 31980 31983 -1]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Other "*")}]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (LhsName
                                                                          name: hardcode_libdirs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$hardcode_libdirs"
                                                                            ) ($ VSub_Name "$hardcode_libdir_separator") ($ VSub_Name "$libdir")
                                                                          )
                                                                        }
                                                                      spids: [31990]
                                                                    )
                                                                  ]
                                                                  spids: [31990]
                                                                )
                                                              ]
                                                              spids: [31986 31987 31998 -1]
                                                            )
                                                          ]
                                                          spids: [31964 31970 32001]
                                                        )
                                                      ]
                                                      spids: [31957 32004]
                                                    )
                                                  ]
                                                  spids: [-1 31934]
                                                )
                                              ]
                                              else_action: [
                                                (C {(eval)} 
                                                  {(Lit_VarLike "flag=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:rpath)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$rpath") (" ") 
                                                            ($ VSub_Name "$flag")
                                                          )
                                                        }
                                                      spids: [32018]
                                                    )
                                                  ]
                                                  spids: [32018]
                                                )
                                              ]
                                              spids: [32007 32026]
                                            )
                                          ]
                                          spids: [-1 31920]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$runpath_var"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: 
                                                {(DQ ($ VSub_Name "$finalize_perm_rpath") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [32053 32060 32062 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_perm_rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ 
                                                                ($ VSub_Name "$finalize_perm_rpath") (" ") ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [32068]
                                                        )
                                                      ]
                                                      spids: [32068]
                                                    )
                                                  ]
                                                  spids: [32065 32066 32075 -1]
                                                )
                                              ]
                                              spids: [32043 32050 32078]
                                            )
                                          ]
                                          spids: [32029 32040]
                                        )
                                      ]
                                      spids: [-1 32081]
                                    )
                                  ]
                                  spids: [31906 32084]
                                )
                              spids: [31902 31904]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_Name "$hardcode_libdir_separator"))}
                                            )
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$hardcode_libdirs"))})
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libdir)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$hardcode_libdirs"))}
                                          spids: [32116]
                                        )
                                      ]
                                      spids: [32116]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "rpath=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        )
                                      } {($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)}
                                    )
                                  ]
                                  spids: [-1 32113]
                                )
                              ]
                              spids: [-1 32131]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:finalize_rpath)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$rpath"))}
                                  spids: [32134]
                                )
                              ]
                              spids: [32134]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$libobjs"))})
                                            (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} 
                                              {(Lit_Other "=")} {(yes)}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ (X) ($ VSub_Name "$compile_command"))
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$SP2NL")})
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$lo2o"))}
                                                          )
                                                          (C {($ VSub_Name "$NL2SP")})
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [32172 32197]
                                              )
                                            }
                                          spids: [32171]
                                        )
                                      ]
                                      spids: [32171]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ (X) 
                                                                ($ VSub_Name "$finalize_command")
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$SP2NL")})
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$lo2o"))}
                                                          )
                                                          (C {($ VSub_Name "$NL2SP")})
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [32201 32226]
                                              )
                                            }
                                          spids: [32200]
                                        )
                                      ]
                                      spids: [32200]
                                    )
                                  ]
                                  spids: [-1 32164]
                                )
                              ]
                              spids: [-1 32229]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dlsyms)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [32233]
                                )
                              ]
                              spids: [32233]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {
                                                (DQ ($ VSub_Name "$dlfiles") 
                                                  ($ VSub_Name "$dlprefiles")
                                                )
                                              }
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$dlself"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$NM"))})
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_Name "$global_symbol_pipe"))}
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dlsyms)
                                                  op: Equal
                                                  rhs: {(DQ (${ VSub_Name outputname) (S.c))}
                                                  spids: [32288]
                                                )
                                              ]
                                              spids: [32288]
                                            )
                                          ]
                                          spids: [-1 32285]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") 
                                                (
": not configured to extract global symbols from dlpreopened files"
                                                )
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [32307]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [32297 32311]
                                    )
                                  ]
                                  spids: [-1 32261]
                                )
                              ]
                              spids: [-1 32314]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dlsyms"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$dlsyms")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(DQ )}]
                                          spids: [-1 32341 32343 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.c)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:nlist)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$output_objdir") (/) 
                                                        (${ VSub_Name outputname) (.nm)
                                                      )
                                                    }
                                                  spids: [32355]
                                                )
                                              ]
                                              spids: [32355]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$rm") (" ") ($ VSub_Name "$nlist") 
                                                  (" ") (${ VSub_Name nlist) ("S ") (${ VSub_Name nlist) (T)
                                                )
                                              }
                                            )
                                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                              {(DQ ($ VSub_Name "$nlist"))} {(DQ (${ VSub_Name nlist) (S))} {(DQ (${ VSub_Name nlist) (T))}
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ("creating ") ($ VSub_Name "$output_objdir") (/) 
                                                  ($ VSub_Name "$dlsyms")
                                                )
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                                (SimpleCommand
                                                  words: [
                                                    {($ VSub_Name "$echo")}
                                                    {
                                                      (DQ ("/* ") ($ VSub_Name "$dlsyms") 
                                                        (" - symbol resolution table for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$outputname") 
                                                        ("' dlsym emulation. */\n") ("/* Generated by ") ($ VSub_Name "$PROGRAM") (" - GNU ") ($ VSub_Name "$PACKAGE") (" ") 
                                                        ($ VSub_Name "$VERSION") ($ VSub_Name "$TIMESTAMP") (" */\n") ("\n") ("#ifdef __cplusplus\n") ("extern ") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (C) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" {\n") ("#endif\n") ("\n") 
                                                        (
"/* Prevent the only kind of declaration conflicts we can make. */\n"
                                                        ) ("#define lt_preloaded_symbols some_other_symbol\n") ("\n") 
                                                        (
"/* External symbol declarations for the compiler. */"
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: 
                                                        {
                                                          (DQ ($ VSub_Name "$output_objdir") (/) 
                                                            ($ VSub_Name "$dlsyms")
                                                          )
                                                        }
                                                      spids: [32436]
                                                    )
                                                  ]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$dlself"))} 
                                                          {(Lit_Other "=")} {(yes)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ("generating symbol list for ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\`">
                                                          ) ($ VSub_Name "$output") ("'")
                                                        )
                                                      }
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                                        (SimpleCommand
                                                          words: [
                                                            {($ VSub_Name "$echo")}
                                                            {(SQ <": @PROGRAM@ ">)}
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: {(DQ ($ VSub_Name "$nlist"))}
                                                              spids: [32521]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:progfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name "$objs") ($ VSub_Name "$old_deplibs")
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$SP2NL")})
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} {(DQ ($ VSub_Name "$lo2o"))}
                                                                          )
                                                                          (C {($ VSub_Name "$NL2SP")})
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [32534 32560]
                                                              )
                                                            }
                                                          spids: [32533]
                                                        )
                                                      ]
                                                      spids: [32533]
                                                    )
                                                    (ForEach
                                                      iter_name: arg
                                                      iter_words: [{($ VSub_Name "$progfiles")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (C {($ VSub_Name "$show")} 
                                                              {
                                                                (DQ 
                                                                  (
"extracting global C symbols from "
                                                                  ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$arg") ("'")
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (DQ ($ VSub_Name "$NM") (" ") 
                                                                  ($ VSub_Name "$arg") (" | ") ($ VSub_Name "$global_symbol_pipe") (" >> '") ($ VSub_Name "$nlist") ("'")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [32572 32601]
                                                        )
                                                      spids: [32568 32570]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$exclude_expsyms")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
"$EGREP -v \" ($exclude_expsyms)$\" \"$nlist\" > \"$nlist\"T"
                                                                  >
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {(SQ <"$mv \"$nlist\"T \"$nlist\"">)}
                                                            )
                                                          ]
                                                          spids: [-1 32616]
                                                        )
                                                      ]
                                                      spids: [-1 32637]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name 
"$export_symbols_regex"
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
"$EGREP -e \"$export_symbols_regex\" \"$nlist\" > \"$nlist\"T"
                                                                  >
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {(SQ <"$mv \"$nlist\"T \"$nlist\"">)}
                                                            )
                                                          ]
                                                          spids: [-1 32652]
                                                        )
                                                      ]
                                                      spids: [-1 32673]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$export_symbols")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:export_symbols)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$outputname") (.exp)
                                                                      )
                                                                    }
                                                                  spids: [32695]
                                                                )
                                                              ]
                                                              spids: [32695]
                                                            )
                                                            (C {($ VSub_Name "$run")} 
                                                              {($ VSub_Name "$rm")} {($ VSub_Name "$export_symbols")}
                                                            )
                                                            (C {($ VSub_Name "$run")} {(eval)} 
                                                              {
                                                                (DQ (${ VSub_Name SED) 
                                                                  (" -n -e '/^: @PROGRAM@ ") (Lit_Other "$") ("/d' -e 's/^.* ") (EscapedLiteralPart token:<Lit_EscapedChar "\\(">) (".*") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\)">
                                                                  ) (Lit_Other "$") (/) (EscapedLiteralPart token:<Lit_EscapedChar "\\1">) ("/p' ")
                                                                ) (SQ <"< \"$nlist\" > \"$export_symbols\"">)
                                                              }
                                                            )
                                                            (Case
                                                              to_match: {($ VSub_Name "$host")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") (cygwin) 
                                                                      (Lit_Other "*")
                                                                    }
                                                                    {(Lit_Other "*") (mingw) 
                                                                      (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {(DQ ("echo EXPORTS ")) 
                                                                        (SQ 
                                                                          <
"> \"$output_objdir/$outputname.def\""
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {
                                                                        (SQ 
                                                                          <
"cat \"$export_symbols\" >> \"$output_objdir/$outputname.def\""
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [32742 32752 32776 -1]
                                                                )
                                                              ]
                                                              spids: [32735 32739 32779]
                                                            )
                                                          ]
                                                          spids: [-1 32692]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {
                                                            (DQ (${ VSub_Name SED) (" -e 's/") 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\(">
                                                              ) ("[].[*^") (Lit_Other "$") ("]") (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (/) 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\\\">
                                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\1">) 
                                                              ("/g' -e 's/^/ /' -e 's/") (Lit_Other "$") (/) (Lit_Other "$") ("/'")
                                                            ) (SQ <" < \"$export_symbols\" > \"$output_objdir/$outputname.exp\"">)
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {
                                                            (SQ 
                                                              <
"grep -f \"$output_objdir/$outputname.exp\" < \"$nlist\" > \"$nlist\"T"
                                                              >
                                                            )
                                                          }
                                                        )
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {(SQ <"mv \"$nlist\"T \"$nlist\"">)}
                                                        )
                                                        (Case
                                                          to_match: {($ VSub_Name "$host")}
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "*") (cygwin) 
                                                                  (Lit_Other "*")
                                                                }
                                                                {(Lit_Other "*") (mingw) 
                                                                  (Lit_Other "*")
                                                                }
                                                              ]
                                                              action: [
                                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                                  {(DQ ("echo EXPORTS ")) 
                                                                    (SQ 
                                                                      <
"> \"$output_objdir/$outputname.def\""
                                                                      >
                                                                    )
                                                                  }
                                                                )
                                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                                  {
                                                                    (SQ 
                                                                      <
"cat \"$nlist\" >> \"$output_objdir/$outputname.def\""
                                                                      >
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                              spids: [32839 32849 32873 -1]
                                                            )
                                                          ]
                                                          spids: [32832 32836 32876]
                                                        )
                                                      ]
                                                      spids: [32782 32879]
                                                    )
                                                  ]
                                                  spids: [-1 32491]
                                                )
                                              ]
                                              spids: [-1 32882]
                                            )
                                            (ForEach
                                              iter_name: arg
                                              iter_words: [{($ VSub_Name "$dlprefiles")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ("extracting global C symbols from ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\`">
                                                          ) ($ VSub_Name "$arg") ("'")
                                                        )
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:name)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$arg")
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(-e)} {(SQ <"s%^.*/%%">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [32909 32927]
                                                              )
                                                            }
                                                          spids: [32908]
                                                        )
                                                      ]
                                                      spids: [32908]
                                                    )
                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                      {(SQ <"$echo \": $name \" >> \"$nlist\"">)}
                                                    )
                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                      {
                                                        (DQ ($ VSub_Name "$NM") (" ") 
                                                          ($ VSub_Name "$arg") (" | ") ($ VSub_Name "$global_symbol_pipe") (" >> '") ($ VSub_Name "$nlist") ("'")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [32895 32955]
                                                )
                                              spids: [32891 32893]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-f)} {(DQ ($ VSub_Name "$nlist"))})
                                                        (SimpleCommand
                                                          words: [{(Lit_Other ":")}]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: {(DQ ($ VSub_Name "$nlist"))}
                                                              spids: [32989]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$exclude_expsyms")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (SimpleCommand
                                                              words: [
                                                                {($ VSub_Name "$EGREP")}
                                                                {(-v)}
                                                                {
                                                                  (DQ (" (") 
                                                                    ($ VSub_Name "$exclude_expsyms") (")") (Lit_Other "$")
                                                                  )
                                                                }
                                                                {(DQ ($ VSub_Name "$nlist"))}
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_Great
                                                                  fd: -1
                                                                  arg_word: 
                                                                    {(DQ ($ VSub_Name "$nlist")) (T)}
                                                                  spids: [33026]
                                                                )
                                                              ]
                                                            )
                                                            (C {($ VSub_Name "$mv")} 
                                                              {(DQ ($ VSub_Name "$nlist")) (T)} {(DQ ($ VSub_Name "$nlist"))}
                                                            )
                                                          ]
                                                          spids: [-1 33008]
                                                        )
                                                      ]
                                                      spids: [-1 33046]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (Pipeline
                                                                  children: [
                                                                    (SimpleCommand
                                                                      words: [
                                                                        {(grep)}
                                                                        {(-v)}
                                                                        {(DQ ("^: "))}
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op_id: Redir_Less
                                                                          fd: -1
                                                                          arg_word: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$nlist")
                                                                              )
                                                                            }
                                                                          spids: [33064]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (SimpleCommand
                                                                                  words: [
                                                                                    {(sort)}
                                                                                    {(-k)}
                                                                                    {(3)}
                                                                                  ]
                                                                                  redirects: [
                                                                                    (Redir
                                                                                      op_id: 
Redir_Less
                                                                                      fd: -1
                                                                                      arg_word: 
                                                                                        {
                                                                                          (
/dev/null
                                                                                          )
                                                                                        }
                                                                                      spids: [33081]
                                                                                    )
                                                                                    (Redir
                                                                                      op_id: 
Redir_Great
                                                                                      fd: -1
                                                                                      arg_word: 
                                                                                        {
                                                                                          (
/dev/null
                                                                                          )
                                                                                        }
                                                                                      spids: [33084]
                                                                                    )
                                                                                    (Redir
                                                                                      op_id: 
Redir_GreatAnd
                                                                                      fd: 2
                                                                                      arg_word: {(1)}
                                                                                      spids: [33087]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {(sort)} {(-k)} {(3)})
                                                                          ]
                                                                          spids: [-1 33091]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (C {(sort)} 
                                                                          {(Lit_Other "+") (2)}
                                                                        )
                                                                      ]
                                                                      spids: [33101 33110]
                                                                    )
                                                                    (SimpleCommand
                                                                      words: [{(uniq)}]
                                                                      redirects: [
                                                                        (Redir
                                                                          op_id: Redir_Great
                                                                          fd: -1
                                                                          arg_word: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name "$nlist")
                                                                              ) (S)
                                                                            }
                                                                          spids: [33117]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                  negated: False
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [(C {(Lit_Other ":")})]
                                                          spids: [-1 33125]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (SimpleCommand
                                                          words: [{(grep)} {(-v)} {(DQ ("^: "))}]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Less
                                                              fd: -1
                                                              arg_word: {(DQ ($ VSub_Name "$nlist"))}
                                                              spids: [33142]
                                                            )
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: 
                                                                {(DQ ($ VSub_Name "$nlist")) (S)}
                                                              spids: [33148]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      spids: [33131 33156]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {(DQ ($ VSub_Name "$nlist")) (S)}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(eval)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_Name 
"$global_symbol_to_cdecl"
                                                                  )
                                                                ) (SQ <" < \"$nlist\"S >> \"$output_objdir/$dlsyms\"">)
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 33172]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (SimpleCommand
                                                          words: [
                                                            {($ VSub_Name "$echo")}
                                                            {(SQ <"/* NONE */">)}
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_DGreat
                                                              fd: -1
                                                              arg_word: 
                                                                {
                                                                  (DQ ($ VSub_Name "$output_objdir") 
                                                                    (/) ($ VSub_Name "$dlsyms")
                                                                  )
                                                                }
                                                              spids: [33194]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      spids: [33185 33203]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ("\n") ("#undef lt_preloaded_symbols\n") 
                                                            ("\n") ("#if defined (__STDC__) && __STDC__\n") ("# define lt_ptr void *\n") ("#else\n") 
                                                            ("# define lt_ptr char *\n") ("# define const\n") ("#endif\n") ("\n") ("/* The mapping between symbol names and symbols. */\n")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$dlsyms")
                                                              )
                                                            }
                                                          spids: [33209]
                                                        )
                                                      ]
                                                    )
                                                    (Case
                                                      to_match: {($ VSub_Name "$host")}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") (cygwin) (Lit_Other "*")}
                                                            {(Lit_Other "*") (mingw) (Lit_Other "*")}
                                                          ]
                                                          action: [
                                                            (SimpleCommand
                                                              words: [
                                                                {($ VSub_Name "$echo")}
                                                                {
                                                                  (DQ 
                                                                    (
"/* DATA imports from DLLs on WIN32 can't be const, because\n"
                                                                    ) ("   runtime relocations are performed -- see ld's documentation\n") ("   on pseudo-relocs */\n") 
                                                                    ("struct {\n")
                                                                  )
                                                                }
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_DGreat
                                                                  fd: -1
                                                                  arg_word: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$dlsyms")
                                                                      )
                                                                    }
                                                                  spids: [33256]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          spids: [33241 33251 33273 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (SimpleCommand
                                                              words: [
                                                                {($ VSub_Name "$echo")}
                                                                {(DQ ("const struct {\n"))}
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_DGreat
                                                                  fd: -1
                                                                  arg_word: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$dlsyms")
                                                                      )
                                                                    }
                                                                  spids: [33283]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          spids: [33276 33278 33297 -1]
                                                        )
                                                      ]
                                                      spids: [33234 33238 33300]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ("  const char *name;\n") 
                                                            ("  lt_ptr address;\n") ("}\n") ("lt_preloaded_symbols[] =\n") ("{")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$dlsyms")
                                                              )
                                                            }
                                                          spids: [33307]
                                                        )
                                                      ]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {(eval)}
                                                        {
                                                          (DQ 
                                                            ($ VSub_Name 
"$global_symbol_to_c_name_address"
                                                            )
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Less
                                                          fd: -1
                                                          arg_word: {(DQ ($ VSub_Name "$nlist"))}
                                                          spids: [33333]
                                                        )
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$dlsyms")
                                                              )
                                                            }
                                                          spids: [33339]
                                                        )
                                                      ]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ("  {0, (lt_ptr) 0}\n") ("};\n") ("\n") 
                                                            (
"/* This works around a problem in FreeBSD linker */\n"
                                                            ) ("#ifdef FREEBSD_WORKAROUND\n") ("static const void *lt_preloaded_setup() {\n") 
                                                            ("  return lt_preloaded_symbols;\n") ("}\n") ("#endif\n") ("\n") ("#ifdef __cplusplus\n") ("}\n") ("#endif")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$dlsyms")
                                                              )
                                                            }
                                                          spids: [33351]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [-1 32970]
                                                )
                                              ]
                                              spids: [-1 33378]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:pic_flag_for_symtable)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [33382]
                                                )
                                              ]
                                              spids: [33382]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$host")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-freebsd2) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-freebsd3.0) 
                                                      (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "*") (-) (Lit_Other "*") 
                                                      (-freebsdelf3.0) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Case
                                                      to_match: 
                                                        {(DQ ($ VSub_Name "$compile_command") (" "))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") (DQ (" -static ")) 
                                                              (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [33442 33447 33449 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: pic_flag_for_symtable
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$pic_flag") (" -DFREEBSD_WORKAROUND")
                                                                      )
                                                                    }
                                                                  spids: [33455]
                                                                )
                                                              ]
                                                              spids: [33455]
                                                            )
                                                          ]
                                                          spids: [33452 33453 33461 -1]
                                                        )
                                                      ]
                                                      spids: [33432 33439 33464]
                                                    )
                                                  ]
                                                  spids: [33412 33429 33465 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (-) (Lit_Other "*") (-hpux) 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Case
                                                      to_match: 
                                                        {(DQ ($ VSub_Name "$compile_command") (" "))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") (DQ (" -static ")) 
                                                              (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [33486 33491 33493 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: pic_flag_for_symtable
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ (" ") 
                                                                        ($ VSub_Name "$pic_flag")
                                                                      )
                                                                    }
                                                                  spids: [33499]
                                                                )
                                                              ]
                                                              spids: [33499]
                                                            )
                                                          ]
                                                          spids: [33496 33497 33504 -1]
                                                        )
                                                      ]
                                                      spids: [33476 33483 33507]
                                                    )
                                                  ]
                                                  spids: [33468 33473 -1 33510]
                                                )
                                              ]
                                              spids: [33385 33389 33510]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ("(cd ") ($ VSub_Name "$output_objdir") (" && ") 
                                                  ($ VSub_Name "$LTCC") ("  ") ($ VSub_Name "$LTCFLAGS") (" -c") ($ VSub_Name "$no_builtin_flag") 
                                                  ($ VSub_Name "$pic_flag_for_symtable") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$dlsyms") 
                                                  (EscapedLiteralPart
                                                    token: <Lit_EscapedChar "\\\"">
                                                  ) (")")
                                                )
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (SQ 
                                                      <
"(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
                                                      >
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$rm") (" ") 
                                                  ($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$dlsyms") (" ") ($ VSub_Name "$nlist") (" ") (${ VSub_Name nlist) ("S ") 
                                                  (${ VSub_Name nlist) (T)
                                                )
                                              }
                                            )
                                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                              {
                                                (DQ ($ VSub_Name "$output_objdir") (/) 
                                                  ($ VSub_Name "$dlsyms")
                                                )
                                              } {(DQ ($ VSub_Name "$nlist"))} {(DQ (${ VSub_Name nlist) (S))} {(DQ (${ VSub_Name nlist) (T))}
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$host")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (cygwin) (Lit_Other "*")}
                                                    {(Lit_Other "*") (mingw) (Lit_Other "*")}
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (.def)
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:compile_command)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$compile_command"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} 
                                                                                    {
                                                                                      (DQ 
                                                                                        (
"s%@SYMFILE@%"
                                                                                        ) ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (".def ") ($ VSub_Name "$output_objdir") (/) 
                                                                                        (${ 
VSub_Name outputname
                                                                                        ) (S.) (${ VSub_Name objext) ("%")
                                                                                      )
                                                                                    }
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [33655 33688]
                                                                      )
                                                                    }
                                                                  spids: [33654]
                                                                )
                                                              ]
                                                              spids: [33654]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: finalize_command
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$finalize_command"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} 
                                                                                    {
                                                                                      (DQ 
                                                                                        (
"s%@SYMFILE@%"
                                                                                        ) ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (".def ") ($ VSub_Name "$output_objdir") (/) 
                                                                                        (${ 
VSub_Name outputname
                                                                                        ) (S.) (${ VSub_Name objext) ("%")
                                                                                      )
                                                                                    }
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [33692 33725]
                                                                      )
                                                                    }
                                                                  spids: [33691]
                                                                )
                                                              ]
                                                              spids: [33691]
                                                            )
                                                          ]
                                                          spids: [-1 33651]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:compile_command)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (CommandSubPart
                                                                    command_list: 
                                                                      (CommandList
                                                                        children: [
                                                                          (Pipeline
                                                                            children: [
                                                                              (C 
                                                                                {
                                                                                  ($ VSub_Name 
"$echo"
                                                                                  )
                                                                                } {(DQ (X) ($ VSub_Name "$compile_command"))}
                                                                              )
                                                                              (C 
                                                                                {
                                                                                  ($ VSub_Name 
"$Xsed"
                                                                                  )
                                                                                } {(-e)} 
                                                                                {
                                                                                  (DQ 
                                                                                    (
"s%@SYMFILE@%"
                                                                                    ) ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (S.) (${ VSub_Name objext) ("%")
                                                                                  )
                                                                                }
                                                                              )
                                                                            ]
                                                                            negated: False
                                                                          )
                                                                        ]
                                                                      )
                                                                    left_token: <Left_Backtick "`">
                                                                    spids: [33732 33759]
                                                                  )
                                                                }
                                                              spids: [33731]
                                                            )
                                                          ]
                                                          spids: [33731]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:finalize_command)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (CommandSubPart
                                                                    command_list: 
                                                                      (CommandList
                                                                        children: [
                                                                          (Pipeline
                                                                            children: [
                                                                              (C 
                                                                                {
                                                                                  ($ VSub_Name 
"$echo"
                                                                                  )
                                                                                } {(DQ (X) ($ VSub_Name "$finalize_command"))}
                                                                              )
                                                                              (C 
                                                                                {
                                                                                  ($ VSub_Name 
"$Xsed"
                                                                                  )
                                                                                } {(-e)} 
                                                                                {
                                                                                  (DQ 
                                                                                    (
"s%@SYMFILE@%"
                                                                                    ) ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (S.) (${ VSub_Name objext) ("%")
                                                                                  )
                                                                                }
                                                                              )
                                                                            ]
                                                                            negated: False
                                                                          )
                                                                        ]
                                                                      )
                                                                    left_token: <Left_Backtick "`">
                                                                    spids: [33763 33790]
                                                                  )
                                                                }
                                                              spids: [33762]
                                                            )
                                                          ]
                                                          spids: [33762]
                                                        )
                                                      ]
                                                      spids: [33728 33793]
                                                    )
                                                  ]
                                                  spids: [33621 33631 33796 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:compile_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name 
"$compile_command"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} 
                                                                            {
                                                                              (DQ ("s%@SYMFILE@%") 
                                                                                ($ VSub_Name 
"$output_objdir"
                                                                                ) (/) (${ VSub_Name outputname) (S.) (${ VSub_Name objext) ("%")
                                                                              )
                                                                            }
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [33805 33832]
                                                              )
                                                            }
                                                          spids: [33804]
                                                        )
                                                      ]
                                                      spids: [33804]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:finalize_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name 
"$finalize_command"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} 
                                                                            {
                                                                              (DQ ("s%@SYMFILE@%") 
                                                                                ($ VSub_Name 
"$output_objdir"
                                                                                ) (/) (${ VSub_Name outputname) (S.) (${ VSub_Name objext) ("%")
                                                                              )
                                                                            }
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [33836 33863]
                                                              )
                                                            }
                                                          spids: [33835]
                                                        )
                                                      ]
                                                      spids: [33835]
                                                    )
                                                  ]
                                                  spids: [33799 33801 33866 -1]
                                                )
                                              ]
                                              spids: [33614 33618 33869]
                                            )
                                          ]
                                          spids: [32346 32348 33872 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": unknown suffix for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$dlsyms") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [33889]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [33875 33876 33898 -1]
                                        )
                                      ]
                                      spids: [32332 32336 33901]
                                    )
                                  ]
                                  spids: [-1 32329]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:compile_command)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {($ VSub_Name "$echo")} 
                                                        {(DQ (X) ($ VSub_Name "$compile_command"))}
                                                      )
                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                        {(DQ ("s% @SYMFILE@%%"))}
                                                      )
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [33925 33942]
                                          )
                                        }
                                      spids: [33924]
                                    )
                                  ]
                                  spids: [33924]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:finalize_command)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {($ VSub_Name "$echo")} 
                                                        {(DQ (X) ($ VSub_Name "$finalize_command"))}
                                                      )
                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                        {(DQ ("s% @SYMFILE@%%"))}
                                                      )
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [33946 33963]
                                          )
                                        }
                                      spids: [33945]
                                    )
                                  ]
                                  spids: [33945]
                                )
                              ]
                              spids: [33904 33966]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(DQ ($ VSub_Name "$need_relink"))} 
                                              {(Lit_Other "=")} {(no)}
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ (X) ($ VSub_Name "$compile_command"))
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%@OUTPUT@%">) 
                                                              (DQ ($ VSub_Name "$output")) (SQ <"%g">)
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [34004 34027]
                                              )
                                            }
                                          spids: [34003]
                                        )
                                      ]
                                      spids: [34003]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_command") 
                                                ($ VSub_Name "$compile_rpath")
                                              )
                                            }
                                          spids: [34030]
                                        )
                                      ]
                                      spids: [34030]
                                    )
                                    (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$link_command"))})
                                    (C {($ VSub_Name "$run")} {(eval)} 
                                      {(DQ ($ VSub_Name "$link_command"))}
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:exit_status)
                                          op: Equal
                                          rhs: {($ VSub_QMark "$?")}
                                          spids: [34058]
                                        )
                                      ]
                                      spids: [34058]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dlsyms"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$rm") (" ") 
                                                  ($ VSub_Name "$output_objdir") (/) (${ VSub_Name outputname) (S.) (${ VSub_Name objext)
                                                )
                                              }
                                            )
                                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                              {
                                                (DQ ($ VSub_Name "$output_objdir") (/) 
                                                  (${ VSub_Name outputname) (S.) (${ VSub_Name objext)
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 34078]
                                        )
                                      ]
                                      spids: [-1 34115]
                                    )
                                    (C {(exit)} {($ VSub_Name "$exit_status")})
                                  ]
                                  spids: [-1 33996]
                                )
                              ]
                              spids: [-1 34124]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath_var"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rpath)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [34146]
                                        )
                                      ]
                                      spids: [34146]
                                    )
                                    (ForEach
                                      iter_name: dir
                                      iter_words: [{($ VSub_Name "$temp_rpath")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Case
                                              to_match: {($ VSub_Name "$dir")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "[") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (/) (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                    {(Lit_Other "[") (A-Za-z) (Lit_Other "]") 
                                                      (Lit_Other ":") (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rpath") 
                                                                ($ VSub_Name "$dir") (":")
                                                              )
                                                            }
                                                          spids: [34192]
                                                        )
                                                      ]
                                                      spids: [34192]
                                                    )
                                                  ]
                                                  spids: [34168 34185 34200 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rpath") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\$">
                                                                ) (thisdir/) ($ VSub_Name "$dir") (":")
                                                              )
                                                            }
                                                          spids: [34211]
                                                        )
                                                      ]
                                                      spids: [34211]
                                                    )
                                                  ]
                                                  spids: [34203 34204 34221 -1]
                                                )
                                              ]
                                              spids: [34161 34165 34224]
                                            )
                                          ]
                                          spids: [34158 34227]
                                        )
                                      spids: [34154 34156]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:temp_rpath)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$rpath"))}
                                          spids: [34230]
                                        )
                                      ]
                                      spids: [34230]
                                    )
                                  ]
                                  spids: [-1 34139]
                                )
                              ]
                              spids: [-1 34236]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {
                                            (DQ ($ VSub_Name "$compile_shlibpath") 
                                              ($ VSub_Name "$finalize_shlibpath")
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$shlibpath_var") ("=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$compile_shlibpath") ($ VSub_Name "$finalize_shlibpath") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ($ VSub_Name "$shlibpath_var") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                ($ VSub_Name "$compile_command")
                                              )
                                            }
                                          spids: [34255]
                                        )
                                      ]
                                      spids: [34255]
                                    )
                                  ]
                                  spids: [-1 34252]
                                )
                              ]
                              spids: [-1 34270]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$finalize_shlibpath"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$shlibpath_var") ("=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$finalize_shlibpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                ($ VSub_Name "$shlibpath_var") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") ($ VSub_Name "$finalize_command")
                                              )
                                            }
                                          spids: [34287]
                                        )
                                      ]
                                      spids: [34287]
                                    )
                                  ]
                                  spids: [-1 34284]
                                )
                              ]
                              spids: [-1 34301]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:compile_var)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [34305]
                                )
                              ]
                              spids: [34305]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:finalize_var)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [34308]
                                )
                              ]
                              spids: [34308]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$runpath_var"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$perm_rpath"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:rpath)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [34343]
                                                )
                                              ]
                                              spids: [34343]
                                            )
                                            (ForEach
                                              iter_name: dir
                                              iter_words: [{($ VSub_Name "$perm_rpath")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rpath") 
                                                                ($ VSub_Name "$dir") (":")
                                                              )
                                                            }
                                                          spids: [34358]
                                                        )
                                                      ]
                                                      spids: [34358]
                                                    )
                                                  ]
                                                  spids: [34355 34366]
                                                )
                                              spids: [34351 34353]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:compile_var)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$runpath_var") ("=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$rpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$runpath_var") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (" ")
                                                      )
                                                    }
                                                  spids: [34369]
                                                )
                                              ]
                                              spids: [34369]
                                            )
                                          ]
                                          spids: [-1 34336]
                                        )
                                      ]
                                      spids: [-1 34382]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_Name "$finalize_perm_rpath"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:rpath)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [34403]
                                                )
                                              ]
                                              spids: [34403]
                                            )
                                            (ForEach
                                              iter_name: dir
                                              iter_words: [{($ VSub_Name "$finalize_perm_rpath")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rpath)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rpath") 
                                                                ($ VSub_Name "$dir") (":")
                                                              )
                                                            }
                                                          spids: [34418]
                                                        )
                                                      ]
                                                      spids: [34418]
                                                    )
                                                  ]
                                                  spids: [34415 34426]
                                                )
                                              spids: [34411 34413]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize_var)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$runpath_var") ("=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$rpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$runpath_var") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (" ")
                                                      )
                                                    }
                                                  spids: [34429]
                                                )
                                              ]
                                              spids: [34429]
                                            )
                                          ]
                                          spids: [-1 34396]
                                        )
                                      ]
                                      spids: [-1 34442]
                                    )
                                  ]
                                  spids: [-1 34322]
                                )
                              ]
                              spids: [-1 34445]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$no_install"))} {(Lit_Other "=")} 
                                          {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_var") 
                                                ($ VSub_Name "$compile_command") ($ VSub_Name "$compile_rpath")
                                              )
                                            }
                                          spids: [34469]
                                        )
                                      ]
                                      spids: [34469]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$link_command"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%@OUTPUT@%">) 
                                                              (DQ ($ VSub_Name "$output")) (SQ <"%g">)
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [34482 34505]
                                              )
                                            }
                                          spids: [34481]
                                        )
                                      ]
                                      spids: [34481]
                                    )
                                    (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                      {($ VSub_Name "$output")}
                                    )
                                    (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$link_command"))})
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {(DQ ($ VSub_Name "$link_command"))}
                                        )
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                                  ]
                                  spids: [-1 34462]
                                )
                              ]
                              spids: [-1 34550]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$hardcode_action"))} 
                                          {(Lit_Other "=")} {(relink)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_var") 
                                                ($ VSub_Name "$compile_command") ($ VSub_Name "$compile_rpath")
                                              )
                                            }
                                          spids: [34574]
                                        )
                                      ]
                                      spids: [34574]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_var") 
                                                ($ VSub_Name "$finalize_command") ($ VSub_Name "$finalize_rpath")
                                              )
                                            }
                                          spids: [34582]
                                        )
                                      ]
                                      spids: [34582]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") 
                                            (
": warning: this platform does not like uninstalled shared libraries"
                                            )
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [34598]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ($ VSub_Name "$output") ("' will be relinked during installation")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [34612]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 34567]
                                )
                              ]
                              else_action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(test)} {(DQ ($ VSub_Name "$fast_install"))} 
                                              {(KW_Bang "!") (Lit_Other "=")} {(no)}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:link_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$finalize_var") 
                                                    ($ VSub_Name "$compile_command") ($ VSub_Name "$finalize_rpath")
                                                  )
                                                }
                                              spids: [34636]
                                            )
                                          ]
                                          spids: [34636]
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C {(test)} {(DQ ($ VSub_Name "$fast_install"))} 
                                                      {(Lit_Other "=")} {(yes)}
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:relink_command)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (Pipeline
                                                                    children: [
                                                                      (C {($ VSub_Name "$echo")} 
                                                                        {
                                                                          (DQ (X) 
                                                                            ($ VSub_Name 
"$compile_var"
                                                                            ) ($ VSub_Name "$compile_command") ($ VSub_Name "$compile_rpath")
                                                                          )
                                                                        }
                                                                      )
                                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                        {
                                                                          (SQ 
                                                                            <
"s%@OUTPUT@%\\$progdir/\\$file%g"
                                                                            >
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: False
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [34661 34680]
                                                          )
                                                        }
                                                      spids: [34660]
                                                    )
                                                  ]
                                                  spids: [34660]
                                                )
                                              ]
                                              spids: [-1 34657]
                                            )
                                          ]
                                          else_action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:relink_command)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [34690]
                                                )
                                              ]
                                              spids: [34690]
                                            )
                                          ]
                                          spids: [34683 34693]
                                        )
                                      ]
                                      spids: [-1 34633]
                                    )
                                  ]
                                  else_action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:link_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$compile_var") 
                                                ($ VSub_Name "$compile_command") ($ VSub_Name "$compile_rpath")
                                              )
                                            }
                                          spids: [34699]
                                        )
                                      ]
                                      spids: [34699]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$finalize_var") 
                                                ($ VSub_Name "$finalize_command") ($ VSub_Name "$finalize_rpath")
                                              )
                                            }
                                          spids: [34707]
                                        )
                                      ]
                                      spids: [34707]
                                    )
                                  ]
                                  spids: [34696 34715]
                                )
                              ]
                              spids: [34616 34718]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:link_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$link_command"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(SQ <"s%@OUTPUT@%">) 
                                                      (DQ ($ VSub_Name "$output_objdir") (/) 
                                                        ($ VSub_Name "$outputname")
                                                      ) (SQ <"%g">)
                                                    }
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [34727 34752]
                                      )
                                    }
                                  spids: [34726]
                                )
                              ]
                              spids: [34726]
                            )
                            (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} {($ VSub_Name "$output")} 
                              {($ VSub_Name "$output_objdir") (/) ($ VSub_Name "$outputname")} {($ VSub_Name "$output_objdir") (/lt-) ($ VSub_Name "$outputname")}
                            )
                            (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$link_command"))})
                            (AndOr
                              children: [
                                (C {($ VSub_Name "$run")} {(eval)} {(DQ ($ VSub_Name "$link_command"))})
                                (C {(exit)} {($ VSub_QMark "$?")})
                              ]
                              op_id: Op_DPipe
                            )
                            (C {($ VSub_Name "$show")} {(DQ ("creating ") ($ VSub_Name "$output"))})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$relink_command"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (ForEach
                                      iter_name: var
                                      iter_words: [{($ VSub_Name "$variables_saved_for_relink")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(eval)} {(test)} {(-z)} 
                                                          {
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (Lit_LBrace "{") ($ VSub_Name "$var") (Lit_Other "+") 
                                                            (set) (Lit_RBrace "}") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:relink_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ("{ test -z ") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("{") ($ VSub_Name "$var") ("+set}") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) (" || unset ") ($ VSub_Name "$var") (" || { ") ($ VSub_Name "$var") ("=; export ") ($ VSub_Name "$var") 
                                                                ("; }; }; ") ($ VSub_Name "$relink_command")
                                                              )
                                                            }
                                                          spids: [34867]
                                                        )
                                                      ]
                                                      spids: [34867]
                                                    )
                                                  ]
                                                  spids: [-1 34864]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(eval)} 
                                                          {(Lit_VarLike "var_value=") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\$">
                                                            ) ($ VSub_Name "$var")
                                                          }
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_Name "$var_value"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:relink_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$var") ("=; export ") 
                                                                ($ VSub_Name "$var") ("; ") ($ VSub_Name "$relink_command")
                                                              )
                                                            }
                                                          spids: [34908]
                                                        )
                                                      ]
                                                      spids: [34908]
                                                    )
                                                  ]
                                                  spids: [34887 34905]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:var_value)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (Pipeline
                                                                    children: [
                                                                      (C {($ VSub_Name "$echo")} 
                                                                        {
                                                                          (DQ (X) 
                                                                            ($ VSub_Name "$var_value")
                                                                          )
                                                                        }
                                                                      )
                                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$sed_quote_subst"
                                                                            )
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: False
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [34922 34939]
                                                          )
                                                        }
                                                      spids: [34921]
                                                    )
                                                  ]
                                                  spids: [34921]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:relink_command)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$var") ("=") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            ) ($ VSub_Name "$var_value") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; export ") 
                                                            ($ VSub_Name "$var") ("; ") ($ VSub_Name "$relink_command")
                                                          )
                                                        }
                                                      spids: [34942]
                                                    )
                                                  ]
                                                  spids: [34942]
                                                )
                                              ]
                                              spids: [34918 34956]
                                            )
                                          ]
                                          spids: [34843 34959]
                                        )
                                      spids: [34839 34841]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ("(cd ") 
                                                (CommandSubPart
                                                  command_list: (CommandList children:[(C {(pwd)})])
                                                  left_token: <Left_Backtick "`">
                                                  spids: [34965 34967]
                                                ) ("; ") ($ VSub_Name "$relink_command") (")")
                                              )
                                            }
                                          spids: [34962]
                                        )
                                      ]
                                      spids: [34962]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {
                                                              (DQ (X) ($ VSub_Name "$relink_command"))
                                                            }
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [34975 34992]
                                              )
                                            }
                                          spids: [34974]
                                        )
                                      ]
                                      spids: [34974]
                                    )
                                  ]
                                  spids: [-1 34827]
                                )
                              ]
                              spids: [-1 34995]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$echo"))} {(Lit_Other "=")} 
                                          {
                                            (DQ (X) ($ VSub_Name "$SHELL") (" ") 
                                              ($ VSub_Name "$progpath") (" --fallback-echo")
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$progpath")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") 
                                              (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:qecho)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$SHELL") (" ") 
                                                        ($ VSub_Name "$progpath") (" --fallback-echo")
                                                      )
                                                    }
                                                  spids: [35052]
                                                )
                                              ]
                                              spids: [35052]
                                            )
                                          ]
                                          spids: [35033 35050 35059 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:qecho)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$SHELL") (" ") 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [(C {(pwd)})]
                                                            )
                                                          left_token: <Left_Backtick "`">
                                                          spids: [35069 35071]
                                                        ) (/) ($ VSub_Name "$progpath") (" --fallback-echo")
                                                      )
                                                    }
                                                  spids: [35065]
                                                )
                                              ]
                                              spids: [35065]
                                            )
                                          ]
                                          spids: [35062 35063 35076 -1]
                                        )
                                      ]
                                      spids: [35026 35030 35079]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:qecho)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$qecho"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [35083 35100]
                                              )
                                            }
                                          spids: [35082]
                                        )
                                      ]
                                      spids: [35082]
                                    )
                                  ]
                                  spids: [-1 35023]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:qecho)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {($ VSub_Name "$echo")} 
                                                        {(DQ (X) ($ VSub_Name "$echo"))}
                                                      )
                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                        {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                      )
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [35107 35124]
                                          )
                                        }
                                      spids: [35106]
                                    )
                                  ]
                                  spids: [35106]
                                )
                              ]
                              spids: [35103 35127]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$output")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.exe)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:output)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {($ VSub_Name "$output")}
                                                                  )
                                                                  (C {(${ VSub_Name SED)} 
                                                                    {(SQ <"s,.exe$,,">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [35169 35181]
                                                      )
                                                    }
                                                  spids: [35168]
                                                )
                                              ]
                                              spids: [35168]
                                            )
                                          ]
                                          spids: [35164 35166 35183 -1]
                                        )
                                      ]
                                      spids: [35157 35161 35186]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (cygwin) (Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:exeext)
                                                  op: Equal
                                                  rhs: {(.exe)}
                                                  spids: [35206]
                                                )
                                              ]
                                              spids: [35206]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:outputname)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {($ VSub_Name "$outputname")}
                                                                  )
                                                                  (C {(${ VSub_Name SED)} 
                                                                    {(SQ <"s,.exe$,,">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [35211 35223]
                                                      )
                                                    }
                                                  spids: [35210]
                                                )
                                              ]
                                              spids: [35210]
                                            )
                                          ]
                                          spids: [35200 35203 35225 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:exeext)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [35231]
                                                )
                                              ]
                                              spids: [35231]
                                            )
                                          ]
                                          spids: [35228 35229 35233 -1]
                                        )
                                      ]
                                      spids: [35193 35197 35236]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (cygwin) (Lit_Other "*")}
                                            {(Lit_Other "*") (mingw) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:output_name)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(basename)} {($ VSub_Name "$output")})
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [35260 35264]
                                                      )
                                                    }
                                                  spids: [35259]
                                                )
                                              ]
                                              spids: [35259]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:output_path)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(dirname)} {($ VSub_Name "$output")})
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [35268 35272]
                                                      )
                                                    }
                                                  spids: [35267]
                                                )
                                              ]
                                              spids: [35267]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:cwrappersource)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$output_path") (/) 
                                                        ($ VSub_Name "$objdir") (/lt-) ($ VSub_Name "$output_name") (.c)
                                                      )
                                                    }
                                                  spids: [35275]
                                                )
                                              ]
                                              spids: [35275]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:cwrapper)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$output_path") (/) 
                                                        ($ VSub_Name "$output_name") (.exe)
                                                      )
                                                    }
                                                  spids: [35286]
                                                )
                                              ]
                                              spids: [35286]
                                            )
                                            (C {($ VSub_Name "$rm")} {($ VSub_Name "$cwrappersource")} 
                                              {($ VSub_Name "$cwrapper")}
                                            )
                                            (C {(trap)} 
                                              {
                                                (DQ ($ VSub_Name "$rm") (" ") 
                                                  ($ VSub_Name "$cwrappersource") (" ") ($ VSub_Name "$cwrapper") ("; exit ") ($ VSub_Name "$EXIT_FAILURE")
                                                )
                                              } {(1)} {(2)} {(15)}
                                            )
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$cwrappersource")}
                                                  spids: [35324]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: 
                                                    {
                                                      (DQ ("\n") ("/* ") 
                                                        ($ VSub_Name "$cwrappersource") (" - temporary wrapper executable for ") ($ VSub_Name "$objdir") (/) ($ VSub_Name "$outputname") ("\n") 
                                                        ("   Generated by ") ($ VSub_Name "$PROGRAM") (" - GNU ") ($ VSub_Name "$PACKAGE") (" ") ($ VSub_Name "$VERSION") 
                                                        ($ VSub_Name "$TIMESTAMP") ("\n") ("\n") ("   The ") ($ VSub_Name "$output") 
                                                        (
" program cannot be directly executed until all the libtool\n"
                                                        ) ("   libraries that it depends on are installed.\n") ("\n") 
                                                        (
"   This wrapper executable should never be moved out of the build directory.\n"
                                                        ) ("   If it is, it will not operate correctly.\n") ("\n") 
                                                        (
"   Currently, it simply execs the wrapper *script* "
                                                        ) (Right_DoubleQuote "\"") ("/bin/sh ") ($ VSub_Name "$output") (Right_DoubleQuote "\"") (",\n") 
                                                        (
"   but could eventually absorb all of the scripts functionality and\n"
                                                        ) ("   exec ") ($ VSub_Name "$objdir") (/) ($ VSub_Name "$outputname") (" directly.\n") ("*/\n")
                                                      )
                                                    }
                                                  do_expansion: True
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [35328]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$cwrappersource")}
                                                  spids: [35372]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: 
                                                    {("#include <stdio.h>\n") 
                                                      ("#include <stdlib.h>\n") ("#include <unistd.h>\n") ("#include <malloc.h>\n") ("#include <stdarg.h>\n") ("#include <assert.h>\n") 
                                                      ("#include <string.h>\n") ("#include <ctype.h>\n") ("#include <sys/stat.h>\n") ("\n") ("#if defined(PATH_MAX)\n") 
                                                      ("# define LT_PATHMAX PATH_MAX\n") ("#elif defined(MAXPATHLEN)\n") ("# define LT_PATHMAX MAXPATHLEN\n") ("#else\n") 
                                                      ("# define LT_PATHMAX 1024\n") ("#endif\n") ("\n") ("#ifndef DIR_SEPARATOR\n") ("# define DIR_SEPARATOR '/'\n") 
                                                      ("# define PATH_SEPARATOR ':'\n") ("#endif\n") ("\n") ("#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \\\n") 
                                                      ("  defined (__OS2__)\n") ("# define HAVE_DOS_BASED_FILE_SYSTEM\n") ("# ifndef DIR_SEPARATOR_2\n") 
                                                      ("#  define DIR_SEPARATOR_2 '\\\\'\n") ("# endif\n") ("# ifndef PATH_SEPARATOR_2\n") ("#  define PATH_SEPARATOR_2 ';'\n") ("# endif\n") 
                                                      ("#endif\n") ("\n") ("#ifndef DIR_SEPARATOR_2\n") ("# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)\n") 
                                                      ("#else /* DIR_SEPARATOR_2 */\n") ("# define IS_DIR_SEPARATOR(ch) \\\n") 
                                                      (
"        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))\n"
                                                      ) ("#endif /* DIR_SEPARATOR_2 */\n") ("\n") ("#ifndef PATH_SEPARATOR_2\n") 
                                                      (
"# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)\n"
                                                      ) ("#else /* PATH_SEPARATOR_2 */\n") ("# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)\n") 
                                                      ("#endif /* PATH_SEPARATOR_2 */\n") ("\n") ("#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))\n") 
                                                      ("#define XFREE(stale) do { \\\n") ("  if (stale) { free ((void *) stale); stale = 0; } \\\n") ("} while (0)\n") ("\n") 
                                                      (
"/* -DDEBUG is fairly common in CFLAGS.  */\n"
                                                      ) ("#undef DEBUG\n") ("#if defined DEBUGWRAPPER\n") 
                                                      (
"# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)\n"
                                                      ) ("#else\n") ("# define DEBUG(format, ...)\n") ("#endif\n") ("\n") ("const char *program_name = NULL;\n") 
                                                      ("\n") ("void * xmalloc (size_t num);\n") ("char * xstrdup (const char *string);\n") 
                                                      (
"const char * base_name (const char *name);\n"
                                                      ) ("char * find_executable(const char *wrapper);\n") ("int    check_executable(const char *path);\n") 
                                                      (
"char * strendzap(char *str, const char *pat);\n"
                                                      ) ("void lt_fatal (const char *message, ...);\n") ("\n") ("int\n") ("main (int argc, char *argv[])\n") 
                                                      ("{\n") ("  char **newargz;\n") ("  int i;\n") ("\n") 
                                                      (
"  program_name = (char *) xstrdup (base_name (argv[0]));\n"
                                                      ) ("  DEBUG(\"(main) argv[0]      : %s\\n\",argv[0]);\n") 
                                                      (
"  DEBUG(\"(main) program_name : %s\\n\",program_name);\n"
                                                      ) ("  newargz = XMALLOC(char *, argc+2);\n")
                                                    }
                                                  do_expansion: False
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [35375]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$cwrappersource")}
                                                  spids: [35384]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: 
                                                    {
                                                      (DQ ("  newargz[0] = (char *) xstrdup(") 
                                                        (Right_DoubleQuote "\"") ($ VSub_Name "$SHELL") (Right_DoubleQuote "\"") (");\n")
                                                      )
                                                    }
                                                  do_expansion: True
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [35388]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$cwrappersource")}
                                                  spids: [35400]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: 
                                                    {("  newargz[1] = find_executable(argv[0]);\n") 
                                                      ("  if (newargz[1] == NULL)\n") ("    lt_fatal(\"Couldn't find %s\", argv[0]);\n") 
                                                      (
"  DEBUG(\"(main) found exe at : %s\\n\",newargz[1]);\n"
                                                      ) ("  /* we know the script has the same name, without the .exe */\n") 
                                                      (
"  /* so make sure newargz[1] doesn't end in .exe */\n"
                                                      ) ("  strendzap(newargz[1],\".exe\");\n") ("  for (i = 1; i < argc; i++)\n") 
                                                      ("    newargz[i+1] = xstrdup(argv[i]);\n") ("  newargz[argc+1] = NULL;\n") ("\n") ("  for (i=0; i<argc+1; i++)\n") ("  {\n") 
                                                      (
"    DEBUG(\"(main) newargz[%d]   : %s\\n\",i,newargz[i]);\n"
                                                      ) ("    ;\n") ("  }\n") ("\n")
                                                    }
                                                  do_expansion: False
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [35404]
                                                )
                                              ]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$host_os")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(mingw) (Lit_Other "*")}]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [{(cat)}]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: {($ VSub_Name "$cwrappersource")}
                                                          spids: [35425]
                                                        )
                                                        (HereDoc
                                                          op_id: Redir_DLess
                                                          fd: -1
                                                          body: 
                                                            {
                                                              (DQ ("  execv(") 
                                                                (Right_DoubleQuote "\"") ($ VSub_Name "$SHELL") (Right_DoubleQuote "\"") (",(char const **)newargz);\n")
                                                              )
                                                            }
                                                          do_expansion: True
                                                          here_end: EOF
                                                          was_filled: True
                                                          spids: [35429]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [35418 35420 35438 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [{(cat)}]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: {($ VSub_Name "$cwrappersource")}
                                                          spids: [35447]
                                                        )
                                                        (HereDoc
                                                          op_id: Redir_DLess
                                                          fd: -1
                                                          body: 
                                                            {
                                                              (DQ ("  execv(") 
                                                                (Right_DoubleQuote "\"") ($ VSub_Name "$SHELL") (Right_DoubleQuote "\"") (",newargz);\n")
                                                              )
                                                            }
                                                          do_expansion: True
                                                          here_end: EOF
                                                          was_filled: True
                                                          spids: [35451]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [35441 35442 35460 -1]
                                                )
                                              ]
                                              spids: [35411 35415 35463]
                                            )
                                            (SimpleCommand
                                              words: [{(cat)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$cwrappersource")}
                                                  spids: [35469]
                                                )
                                                (HereDoc
                                                  op_id: Redir_DLess
                                                  fd: -1
                                                  body: 
                                                    {("  return 127;\n") ("}\n") ("\n") ("void *\n") 
                                                      ("xmalloc (size_t num)\n") ("{\n") ("  void * p = (void *) malloc (num);\n") ("  if (!p)\n") 
                                                      ("    lt_fatal (\"Memory exhausted\");\n") ("\n") ("  return p;\n") ("}\n") ("\n") ("char *\n") ("xstrdup (const char *string)\n") ("{\n") 
                                                      (
"  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL\n"
                                                      ) (";\n") ("}\n") ("\n") ("const char *\n") ("base_name (const char *name)\n") ("{\n") 
                                                      ("  const char *base;\n") ("\n") ("#if defined (HAVE_DOS_BASED_FILE_SYSTEM)\n") 
                                                      (
"  /* Skip over the disk name in MSDOS pathnames. */\n"
                                                      ) ("  if (isalpha ((unsigned char)name[0]) && name[1] == ':')\n") ("    name += 2;\n") ("#endif\n") ("\n") 
                                                      ("  for (base = name; *name; name++)\n") ("    if (IS_DIR_SEPARATOR (*name))\n") ("      base = name + 1;\n") ("  return base;\n") ("}\n") ("\n") 
                                                      ("int\n") ("check_executable(const char * path)\n") ("{\n") ("  struct stat st;\n") ("\n") 
                                                      (
"  DEBUG(\"(check_executable)  : %s\\n\", path ? (*path ? path : \"EMPTY!\") : \"NULL!\");\n"
                                                      ) ("  if ((!path) || (!*path))\n") ("    return 0;\n") ("\n") ("  if ((stat (path, &st) >= 0) &&\n") 
                                                      ("      (\n") ("        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */\n") ("#if defined (S_IXOTH)\n") 
                                                      (
"       ((st.st_mode & S_IXOTH) == S_IXOTH) ||\n"
                                                      ) ("#endif\n") ("#if defined (S_IXGRP)\n") ("       ((st.st_mode & S_IXGRP) == S_IXGRP) ||\n") 
                                                      ("#endif\n") ("       ((st.st_mode & S_IXUSR) == S_IXUSR))\n") ("      )\n") ("    return 1;\n") ("  else\n") 
                                                      ("    return 0;\n") ("}\n") ("\n") ("/* Searches for the full path of the wrapper.  Returns\n") 
                                                      (
"   newly allocated full path name if found, NULL otherwise */\n"
                                                      ) ("char *\n") ("find_executable (const char* wrapper)\n") ("{\n") ("  int has_slash = 0;\n") 
                                                      ("  const char* p;\n") ("  const char* p_next;\n") ("  /* static buffer for getcwd */\n") ("  char tmp[LT_PATHMAX + 1];\n") 
                                                      ("  int tmp_len;\n") ("  char* concat_name;\n") ("\n") 
                                                      (
"  DEBUG(\"(find_executable)  : %s\\n\", wrapper ? (*wrapper ? wrapper : \"EMPTY!\") : \"NULL!\");\n"
                                                      ) ("\n") ("  if ((wrapper == NULL) || (*wrapper == '\\0'))\n") ("    return NULL;\n") ("\n") 
                                                      ("  /* Absolute path? */\n") ("#if defined (HAVE_DOS_BASED_FILE_SYSTEM)\n") 
                                                      (
"  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')\n"
                                                      ) ("  {\n") ("    concat_name = xstrdup (wrapper);\n") ("    if (check_executable(concat_name))\n") 
                                                      ("      return concat_name;\n") ("    XFREE(concat_name);\n") ("  }\n") ("  else\n") ("  {\n") ("#endif\n") 
                                                      ("    if (IS_DIR_SEPARATOR (wrapper[0]))\n") ("    {\n") ("      concat_name = xstrdup (wrapper);\n") ("      if (check_executable(concat_name))\n") 
                                                      ("        return concat_name;\n") ("      XFREE(concat_name);\n") ("    }\n") ("#if defined (HAVE_DOS_BASED_FILE_SYSTEM)\n") ("  }\n") 
                                                      ("#endif\n") ("\n") ("  for (p = wrapper; *p; p++)\n") ("    if (*p == '/')\n") ("    {\n") ("      has_slash = 1;\n") 
                                                      ("      break;\n") ("    }\n") ("  if (!has_slash)\n") ("  {\n") ("    /* no slashes; search PATH */\n") 
                                                      (
"    const char* path = getenv (\"PATH\");\n"
                                                      ) ("    if (path != NULL)\n") ("    {\n") ("      for (p = path; *p; p = p_next)\n") ("      {\n") 
                                                      ("        const char* q;\n") ("        size_t p_len;\n") ("        for (q = p; *q; q++)\n") 
                                                      ("          if (IS_PATH_SEPARATOR(*q))\n") ("            break;\n") ("        p_len = q - p;\n") ("        p_next = (*q == '\\0' ? q : q + 1);\n") 
                                                      ("        if (p_len == 0)\n") ("        {\n") ("          /* empty path: current directory */\n") 
                                                      (
"          if (getcwd (tmp, LT_PATHMAX) == NULL)\n"
                                                      ) ("            lt_fatal (\"getcwd failed\");\n") ("          tmp_len = strlen(tmp);\n") 
                                                      (
"          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);\n"
                                                      ) ("          memcpy (concat_name, tmp, tmp_len);\n") ("          concat_name[tmp_len] = '/';\n") 
                                                      (
"          strcpy (concat_name + tmp_len + 1, wrapper);\n"
                                                      ) ("        }\n") ("        else\n") ("        {\n") 
                                                      (
"          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);\n"
                                                      ) ("          memcpy (concat_name, p, p_len);\n") ("          concat_name[p_len] = '/';\n") 
                                                      (
"          strcpy (concat_name + p_len + 1, wrapper);\n"
                                                      ) ("        }\n") ("        if (check_executable(concat_name))\n") ("          return concat_name;\n") 
                                                      ("        XFREE(concat_name);\n") ("      }\n") ("    }\n") ("    /* not found in PATH; assume curdir */\n") ("  }\n") 
                                                      (
"  /* Relative path | not found in path: prepend cwd */\n"
                                                      ) ("  if (getcwd (tmp, LT_PATHMAX) == NULL)\n") ("    lt_fatal (\"getcwd failed\");\n") 
                                                      ("  tmp_len = strlen(tmp);\n") ("  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);\n") 
                                                      ("  memcpy (concat_name, tmp, tmp_len);\n") ("  concat_name[tmp_len] = '/';\n") ("  strcpy (concat_name + tmp_len + 1, wrapper);\n") ("\n") 
                                                      ("  if (check_executable(concat_name))\n") ("    return concat_name;\n") ("  XFREE(concat_name);\n") ("  return NULL;\n") ("}\n") ("\n") ("char *\n") 
                                                      ("strendzap(char *str, const char *pat)\n") ("{\n") ("  size_t len, patlen;\n") ("\n") ("  assert(str != NULL);\n") ("  assert(pat != NULL);\n") 
                                                      ("\n") ("  len = strlen(str);\n") ("  patlen = strlen(pat);\n") ("\n") ("  if (patlen <= len)\n") ("  {\n") 
                                                      ("    str += len - patlen;\n") ("    if (strcmp(str, pat) == 0)\n") ("      *str = '\\0';\n") ("  }\n") ("  return str;\n") ("}\n") 
                                                      ("\n") ("static void\n") ("lt_error_core (int exit_status, const char * mode,\n") 
                                                      (
"          const char * message, va_list ap)\n"
                                                      ) ("{\n") ("  fprintf (stderr, \"%s: %s: \", program_name, mode);\n") 
                                                      ("  vfprintf (stderr, message, ap);\n") ("  fprintf (stderr, \".\\n\");\n") ("\n") ("  if (exit_status >= 0)\n") ("    exit (exit_status);\n") 
                                                      ("}\n") ("\n") ("void\n") ("lt_fatal (const char *message, ...)\n") ("{\n") ("  va_list ap;\n") 
                                                      ("  va_start (ap, message);\n") ("  lt_error_core (EXIT_FAILURE, \"FATAL\", message, ap);\n") ("  va_end (ap);\n") ("}\n")
                                                    }
                                                  do_expansion: False
                                                  here_end: EOF
                                                  was_filled: True
                                                  spids: [35473]
                                                )
                                              ]
                                            )
                                            (C {($ VSub_Name "$run")} {($ VSub_Name "$LTCC")} 
                                              {($ VSub_Name "$LTCFLAGS")} {(-s)} {(-o)} {($ VSub_Name "$cwrapper")} {($ VSub_Name "$cwrappersource")}
                                            )
                                          ]
                                          spids: [35246 35256 35514 -1]
                                        )
                                      ]
                                      spids: [35239 35243 35517]
                                    )
                                    (C {($ VSub_Name "$rm")} {($ VSub_Name "$output")})
                                    (C {(trap)} 
                                      {
                                        (DQ ($ VSub_Name "$rm") (" ") ($ VSub_Name "$output") 
                                          ("; exit ") ($ VSub_Name "$EXIT_FAILURE")
                                        )
                                      } {(1)} {(2)} {(15)}
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ("#! ") ($ VSub_Name "$SHELL") ("\n") ("\n") ("# ") 
                                            ($ VSub_Name "$output") (" - temporary wrapper script for ") ($ VSub_Name "$objdir") (/) ($ VSub_Name "$outputname") ("\n") 
                                            ("# Generated by ") ($ VSub_Name "$PROGRAM") (" - GNU ") ($ VSub_Name "$PACKAGE") (" ") ($ VSub_Name "$VERSION") 
                                            ($ VSub_Name "$TIMESTAMP") ("\n") ("#\n") ("# The ") ($ VSub_Name "$output") 
                                            (
" program cannot be directly executed until all the libtool\n"
                                            ) ("# libraries that it depends on are installed.\n") ("#\n") 
                                            (
"# This wrapper script should never be moved out of the build directory.\n"
                                            ) ("# If it is, it will not operate correctly.\n") ("\n") 
                                            (
"# Sed substitution that helps us do robust quoting.  It backslashifies\n"
                                            ) ("# metacharacters that are still active within double-quoted strings.\n") ("Xsed='") 
                                            (${ VSub_Name SED) (" -e 1s/^X//'\n") ("sed_quote_subst='") ($ VSub_Name "$sed_quote_subst") ("'\n") ("\n") 
                                            (
"# The HP-UX ksh and POSIX shell print the target directory to stdout\n"
                                            ) ("# if CDPATH is set.\n") ("(unset CDPATH) >/dev/null 2>&1 && unset CDPATH\n") ("\n") 
                                            ("relink_command=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$relink_command") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("\n") ("\n") ("# This environment variable determines our operation mode.\n") ("if test ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (libtool_install_magic) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" = ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$magic") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("; then\n") ("  # install mode needs the following variable:\n") ("  notinst_deplibs='") 
                                            ($ VSub_Name "$notinst_deplibs") ("'\n") ("else\n") ("  # When we are sourced in execute mode, ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("file and ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo are already set.\n") 
                                            ("  if test ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                            (libtool_execute_magic) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" != ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ($ VSub_Name "$magic") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; then\n") ("    echo=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ($ VSub_Name "$qecho") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("\n") ("    file=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (0) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("\n") ("    # Make sure echo works.\n") ("    if test ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (X) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (1) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" = X--no-reexec; then\n") ("      # Discard the --no-reexec flag, and continue.\n") ("      shift\n") 
                                            ("    elif test ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("(") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo '") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\t">
                                            ) ("') 2>/dev/null") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" = 'X") (EscapedLiteralPart token:<Lit_EscapedChar "\\t">) ("'; then\n") ("      # Yippee, ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("echo works!\n") ("      :\n") ("    else\n") 
                                            (
"      # Restart under the correct shell, and then maybe "
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo will work.\n") ("      exec ") 
                                            ($ VSub_Name "$SHELL") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (0) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" --no-reexec ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("{1+") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("@") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("}\n") ("    fi\n") ("  fi")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {($ VSub_Name "$output")}
                                          spids: [35545]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ("\n") 
                                            ("  # Find the directory that this script lives in.\n") ("  thisdir=") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("echo ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" | ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("Xsed -e 's%/[^/]*") (Lit_Other "$") ("%%'") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("\n") 
                                            ("  test ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (x) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (thisdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" = ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (x) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" && thisdir=.\n") ("\n") ("  # Follow symbolic links until we get to the real thisdir.\n") ("  file=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("ls -ld ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" | ") (${ VSub_Name SED) 
                                            (" -n 's/.*-> //p'") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("\n") ("  while test -n ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("; do\n") ("    destdir=") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("echo ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" | ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("Xsed -e 's%/[^/]*") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("%%'") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("\n") ("\n") ("    # If there was a directory component, then change thisdir.\n") ("    if test ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (x) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (destdir) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" != ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (x) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; then\n") ("      case ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (destdir) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" in\n") ("      [") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\\">
                                            ) ("/]* | [A-Za-z]:[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\\">
                                            ) ("/]*) thisdir=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (destdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ;;\n") ("      *) thisdir=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (thisdir/) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (destdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ;;\n") ("      esac\n") ("    fi\n") 
                                            ("\n") ("    file=") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("echo ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" | ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("Xsed -e 's%^.*/%%'") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("\n") ("    file=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("ls -ld ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (thisdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" | ") (${ VSub_Name SED) (" -n 's/.*-> //p'") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("\n") 
                                            ("  done\n") ("\n") ("  # Try to get the absolute directory name.\n") ("  absdir=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("cd ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (thisdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" && pwd") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("\n") ("  test -n ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (absdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" && thisdir=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (absdir) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("\n")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_DGreat
                                          fd: -1
                                          arg_word: {($ VSub_Name "$output")}
                                          spids: [35697]
                                        )
                                      ]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$fast_install"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("  program=lt-'") ($ VSub_Name "$outputname") 
                                                    ("'") ($ VSub_Name "$exeext") ("\n") ("  progdir=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (thisdir/) ($ VSub_Name "$objdir") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("\n") ("\n") 
                                                    ("  if test ! -f ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                    (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (" || ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ("\n") ("     { file=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("ls -1dt ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/../) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (" 2>/dev/null | ") (${ VSub_Name SED) (" 1q") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("; ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\\">
                                                    ) ("\n") ("       test ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" != ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (X) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; }; then\n") ("\n") ("    file=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                    (-) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ("\n") ("\n") ("    if test ! -d ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; then\n") ("      ") 
                                                    ($ VSub_Name "$mkdir") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("\n") ("    else\n") ("      ") 
                                                    ($ VSub_Name "$rm") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ("\n") ("    fi")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [35892]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("\n") 
                                                    ("    # relink executable if necessary\n") ("    if test -n ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (relink_command) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; then\n") 
                                                    ("      if relink_command_output=") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("eval ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("relink_command 2>&1") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("; then :\n") 
                                                    ("      else\n") ("\t") ($ VSub_Name "$echo") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (relink_command_output) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" >&2\n") ("\t") 
                                                    ($ VSub_Name "$rm") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ("\n") ("\texit ") ($ VSub_Name "$EXIT_FAILURE") ("\n") ("      fi\n") ("    fi\n") ("\n") ("    ") 
                                                    ($ VSub_Name "$mv") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (file) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (" 2>/dev/null ||\n") ("    { ") ($ VSub_Name "$rm") (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (";\n") ("      ") ($ VSub_Name "$mv") (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; }\n") ("    ") ($ VSub_Name "$rm") (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (file) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("\n") ("  fi")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [36004]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 35887]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ("  program='") ($ VSub_Name "$outputname") ("'\n") 
                                                ("  progdir=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                (thisdir/) ($ VSub_Name "$objdir") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("\n")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_DGreat
                                              fd: -1
                                              arg_word: {($ VSub_Name "$output")}
                                              spids: [36113]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [36108 36132]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ("\n") ("  if test -f ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; then")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_DGreat
                                          fd: -1
                                          arg_word: {($ VSub_Name "$output")}
                                          spids: [36138]
                                        )
                                      ]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (AndOr
                                                  children: [
                                                    (C {(test)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_Name "$shlibpath_overrides_runpath")
                                                        )
                                                      } {(Lit_Other "=")} {(yes)}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$shlibpath_var"))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$temp_rpath"))}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("    # Add our own library path to ") 
                                                    ($ VSub_Name "$shlibpath_var") ("\n") ("    ") ($ VSub_Name "$shlibpath_var") ("=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    ($ VSub_Name "$temp_rpath") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$shlibpath_var") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ("\n") ("\n") ("    # Some systems cannot cope with colon-terminated ") ($ VSub_Name "$shlibpath_var") 
                                                    ("\n") ("    # The second colon is a workaround for a bug in BeOS R4 sed\n") ("    ") 
                                                    ($ VSub_Name "$shlibpath_var") ("=") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("echo ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (X) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ($ VSub_Name "$shlibpath_var") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" | ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("Xsed -e 's/::*") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("//'") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ("\n") ("\n") ("    export ") ($ VSub_Name "$shlibpath_var") ("\n")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [36199]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 36194]
                                        )
                                      ]
                                      spids: [-1 36247]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dllsearchpath"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ 
                                                    (
"    # Add the dll search path components to the executable PATH\n"
                                                    ) ("    PATH=") ($ VSub_Name "$dllsearchpath") (":") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                    ("PATH\n")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [36271]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 36266]
                                        )
                                      ]
                                      spids: [-1 36286]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ("    if test ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (libtool_execute_magic) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" != ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$magic") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("; then\n") ("      # Run the actual program with our arguments.\n")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_DGreat
                                          fd: -1
                                          arg_word: {($ VSub_Name "$output")}
                                          spids: [36292]
                                        )
                                      ]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-mingw)}
                                            {(Lit_Other "*") (-) (Lit_Other "*") (-os2) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("      exec ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\\">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                    (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("{1+") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("@") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("}\n")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [36340]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [36323 36335 36366 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("      exec ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (progdir/) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (program) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("{1+") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("@") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("}\n")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_DGreat
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [36376]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [36370 36371 36400 -1]
                                        )
                                      ]
                                      spids: [36312 36316 36403]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ("      ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("echo ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("0: cannot exec ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("program ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("{1+") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("@") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("}") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("\n") ("      exit ") ($ VSub_Name "$EXIT_FAILURE") ("\n") ("    fi\n") ("  else\n") 
                                            ("    # The program doesn't exist.\n") ("    ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0: error: ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\\">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                            (progdir/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("program' does not exist") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" 1>&2\n") ("    ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ("This script is just a wrapper for ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (program.) 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" 1>&2\n") ("    ") ($ VSub_Name "$echo") (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            ("See the ") ($ VSub_Name "$PACKAGE") (" documentation for more information.") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (" 1>&2\n") ("    exit ") ($ VSub_Name "$EXIT_FAILURE") ("\n") ("  fi\n") (fi)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_DGreat
                                          fd: -1
                                          arg_word: {($ VSub_Name "$output")}
                                          spids: [36408]
                                        )
                                      ]
                                    )
                                    (C {(chmod)} {(Lit_Other "+") (x)} {($ VSub_Name "$output")})
                                  ]
                                  spids: [-1 35146]
                                )
                              ]
                              spids: [-1 36486]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                          ]
                          spids: [30884 30885 36494 -1]
                        )
                      ]
                      spids: [21445 21449 36497]
                    )
                    (ForEach
                      iter_name: oldlib
                      iter_words: [{($ VSub_Name "$oldlibs")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                          {(Lit_Other "=")} {(convenience)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$libobjs_save"))}
                                          spids: [36534]
                                        )
                                      ]
                                      spids: [36534]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:addlibs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$convenience"))}
                                          spids: [36540]
                                        )
                                      ]
                                      spids: [36540]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:build_libtool_libs)
                                          op: Equal
                                          rhs: {(no)}
                                          spids: [36546]
                                        )
                                      ]
                                      spids: [36546]
                                    )
                                  ]
                                  spids: [-1 36531]
                                )
                              ]
                              else_action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                              {(Lit_Other "=")} {(module)}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:oldobjs)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$libobjs_save"))}
                                              spids: [36569]
                                            )
                                          ]
                                          spids: [36569]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:build_libtool_libs)
                                              op: Equal
                                              rhs: {(no)}
                                              spids: [36575]
                                            )
                                          ]
                                          spids: [36575]
                                        )
                                      ]
                                      spids: [-1 36566]
                                    )
                                  ]
                                  else_action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$old_deplibs") (" ") 
                                                ($ VSub_Name "$non_pic_objects")
                                              )
                                            }
                                          spids: [36582]
                                        )
                                      ]
                                      spids: [36582]
                                    )
                                  ]
                                  spids: [36579 36590]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:addlibs)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$old_convenience"))}
                                      spids: [36593]
                                    )
                                  ]
                                  spids: [36593]
                                )
                              ]
                              spids: [36550 36599]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$addlibs"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:gentop)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                (${ VSub_Name outputname) (x)
                                              )
                                            }
                                          spids: [36617]
                                        )
                                      ]
                                      spids: [36617]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:generated)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$generated") (" ") 
                                                ($ VSub_Name "$gentop")
                                              )
                                            }
                                          spids: [36628]
                                        )
                                      ]
                                      spids: [36628]
                                    )
                                    (C {(func_extract_archives)} {($ VSub_Name "$gentop")} 
                                      {($ VSub_Name "$addlibs")}
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$oldobjs") (" ") 
                                                ($ VSub_Name "$func_extract_archives_result")
                                              )
                                            }
                                          spids: [36644]
                                        )
                                      ]
                                      spids: [36644]
                                    )
                                  ]
                                  spids: [-1 36614]
                                )
                              ]
                              spids: [-1 36652]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_Name "$old_archive_from_new_cmds"))}
                                            )
                                            (C {(test)} {(DQ ($ VSub_Name "$build_libtool_libs"))} 
                                              {(Lit_Other "=")} {(yes)}
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:cmds)
                                          op: Equal
                                          rhs: {($ VSub_Name "$old_archive_from_new_cmds")}
                                          spids: [36686]
                                        )
                                      ]
                                      spids: [36686]
                                    )
                                  ]
                                  spids: [-1 36683]
                                )
                              ]
                              else_action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (Subshell
                                              child: 
                                                (Pipeline
                                                  children: [
                                                    (ForEach
                                                      iter_name: obj
                                                      iter_words: [{($ VSub_Name "$oldobjs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Pipeline
                                                              children: [
                                                                (C {($ VSub_Name "$echo")} 
                                                                  {(DQ (X) ($ VSub_Name "$obj"))}
                                                                )
                                                                (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                  {(SQ <"s%^.*/%%">)}
                                                                )
                                                              ]
                                                              negated: False
                                                            )
                                                          ]
                                                          spids: [36729 36750]
                                                        )
                                                      spids: [36725 -1]
                                                    )
                                                    (C {(sort)})
                                                    (SimpleCommand
                                                      words: [{(sort)} {(-uc)}]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Great
                                                          fd: -1
                                                          arg_word: {(/dev/null)}
                                                          spids: [36762]
                                                        )
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 2
                                                          arg_word: {(1)}
                                                          spids: [36765]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: False
                                                )
                                              spids: [36719 36767]
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [(C {(Lit_Other ":")})]
                                      spids: [-1 36770]
                                    )
                                  ]
                                  else_action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {
                                        (DQ 
                                          (
"copying selected object files to avoid basename conflicts..."
                                          )
                                        )
                                      }
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$gentop"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:gentop)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$output_objdir") (/) 
                                                        (${ VSub_Name outputname) (x)
                                                      )
                                                    }
                                                  spids: [36801]
                                                )
                                              ]
                                              spids: [36801]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:generated)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$generated") (" ") 
                                                        ($ VSub_Name "$gentop")
                                                      )
                                                    }
                                                  spids: [36812]
                                                )
                                              ]
                                              spids: [36812]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {(DQ (${ VSub_Name rm) ("r ") ($ VSub_Name "$gentop"))}
                                            )
                                            (C {($ VSub_Name "$run")} {(${ VSub_Name rm) (r)} 
                                              {(DQ ($ VSub_Name "$gentop"))}
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$mkdir") (" ") 
                                                  ($ VSub_Name "$gentop")
                                                )
                                              }
                                            )
                                            (C {($ VSub_Name "$run")} {($ VSub_Name "$mkdir")} 
                                              {(DQ ($ VSub_Name "$gentop"))}
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:exit_status)
                                                  op: Equal
                                                  rhs: {($ VSub_QMark "$?")}
                                                  spids: [36862]
                                                )
                                              ]
                                              spids: [36862]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$exit_status"))} {(-ne)} {(0)}
                                                            )
                                                            (C {(test)} {(KW_Bang "!")} {(-d)} 
                                                              {(DQ ($ VSub_Name "$gentop"))}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [(C {(exit)} {($ VSub_Name "$exit_status")})]
                                                  spids: [-1 36891]
                                                )
                                              ]
                                              spids: [-1 36899]
                                            )
                                          ]
                                          spids: [-1 36798]
                                        )
                                      ]
                                      spids: [-1 36902]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:save_oldobjs)
                                          op: Equal
                                          rhs: {($ VSub_Name "$oldobjs")}
                                          spids: [36906]
                                        )
                                      ]
                                      spids: [36906]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [36910]
                                        )
                                      ]
                                      spids: [36910]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:counter)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [36913]
                                        )
                                      ]
                                      spids: [36913]
                                    )
                                    (ForEach
                                      iter_name: obj
                                      iter_words: [{($ VSub_Name "$save_oldobjs")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:objbase)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$obj"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(SQ <"s%^.*/%%">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [36930 36947]
                                                      )
                                                    }
                                                  spids: [36929]
                                                )
                                              ]
                                              spids: [36929]
                                            )
                                            (Case
                                              to_match: {(DQ (" ") ($ VSub_Name "$oldobjs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(DQ (" "))}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:oldobjs)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$obj")}
                                                          spids: [36966]
                                                        )
                                                      ]
                                                      spids: [36966]
                                                    )
                                                  ]
                                                  spids: [36962 36964 36969 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (Lit_Other "[") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\ ">
                                                      ) (/) (Lit_Other "]") (DQ ($ VSub_Name "$objbase") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (While
                                                      cond: [
                                                        (Sentence
                                                          child: (C {(Lit_Other ":")})
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:newobj)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(lt) ($ VSub_Name "$counter") 
                                                                      (-) ($ VSub_Name "$objbase")
                                                                    }
                                                                  spids: [37001]
                                                                )
                                                              ]
                                                              spids: [37001]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:counter)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (C {(expr)} 
                                                                                {
                                                                                  ($ VSub_Name 
"$counter"
                                                                                  )
                                                                                } {(Lit_Other "+")} {(1)}
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [37009 37017]
                                                                      )
                                                                    }
                                                                  spids: [37008]
                                                                )
                                                              ]
                                                              spids: [37008]
                                                            )
                                                            (Case
                                                              to_match: 
                                                                {
                                                                  (DQ (" ") ($ VSub_Name "$oldobjs") 
                                                                    (" ")
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") (Lit_Other "[") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\ ">
                                                                      ) (/) (Lit_Other "]") (DQ ($ VSub_Name "$newobj") (" ")) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  spids: [37031 37041 37043 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {(KW_Bang "!")} {(-f)} {(DQ ($ VSub_Name "$gentop") (/) ($ VSub_Name "$newobj"))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Sentence
                                                                              child: 
                                                                                (ControlFlow
                                                                                  token: 
                                                                                    <
ControlFlow_Break break
                                                                                    >
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          spids: [-1 37064]
                                                                        )
                                                                      ]
                                                                      spids: [-1 37069]
                                                                    )
                                                                  ]
                                                                  spids: [37046 37047 37071 -1]
                                                                )
                                                              ]
                                                              spids: [37020 37028 37074]
                                                            )
                                                          ]
                                                          spids: [36990 37077]
                                                        )
                                                    )
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ("ln ") ($ VSub_Name "$obj") (" ") 
                                                          ($ VSub_Name "$gentop") (/) ($ VSub_Name "$newobj") (" || cp ") ($ VSub_Name "$obj") (" ") ($ VSub_Name "$gentop") (/) 
                                                          ($ VSub_Name "$newobj")
                                                        )
                                                      }
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {($ VSub_Name "$run")} {(ln)} 
                                                          {(DQ ($ VSub_Name "$obj"))} {(DQ ($ VSub_Name "$gentop") (/) ($ VSub_Name "$newobj"))}
                                                        )
                                                        (C {($ VSub_Name "$run")} {(cp)} 
                                                          {(DQ ($ VSub_Name "$obj"))} {(DQ ($ VSub_Name "$gentop") (/) ($ VSub_Name "$newobj"))}
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:oldobjs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$oldobjs") (" ") 
                                                                ($ VSub_Name "$gentop") (/) ($ VSub_Name "$newobj")
                                                              )
                                                            }
                                                          spids: [37130]
                                                        )
                                                      ]
                                                      spids: [37130]
                                                    )
                                                  ]
                                                  spids: [36972 36982 37140 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:oldobjs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$oldobjs") (" ") 
                                                                ($ VSub_Name "$obj")
                                                              )
                                                            }
                                                          spids: [37146]
                                                        )
                                                      ]
                                                      spids: [37146]
                                                    )
                                                  ]
                                                  spids: [37143 37144 37153 -1]
                                                )
                                              ]
                                              spids: [36950 36958 37156]
                                            )
                                          ]
                                          spids: [36926 37159]
                                        )
                                      spids: [36922 -1]
                                    )
                                  ]
                                  spids: [36776 37162]
                                )
                                (C {(eval)} 
                                  {(Lit_VarLike "cmds=") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\\"">
                                    ) ($ VSub_Name "$old_archive_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                  }
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (AndOr
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:len)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(expr)} 
                                                                    {(DQ (X) ($ VSub_Name "$cmds"))} {(Lit_Other ":")} {(DQ (".*"))}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [37178 37191]
                                                          )
                                                        }
                                                      spids: [37177]
                                                    )
                                                  ]
                                                  spids: [37177]
                                                )
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name "$len"))} {(-le)} 
                                                      {(DQ ($ VSub_Name "$max_cmd_len"))}
                                                    )
                                                    (C {(test)} {(DQ ($ VSub_Name "$max_cmd_len"))} 
                                                      {(-le)} {(-1)}
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:cmds)
                                              op: Equal
                                              rhs: {($ VSub_Name "$old_archive_cmds")}
                                              spids: [37224]
                                            )
                                          ]
                                          spids: [37224]
                                        )
                                      ]
                                      spids: [-1 37221]
                                    )
                                  ]
                                  else_action: [
                                    (C {($ VSub_Name "$echo")} 
                                      {(DQ ("using piecewise archive linking..."))}
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:save_RANLIB)
                                          op: Equal
                                          rhs: {($ VSub_Name "$RANLIB")}
                                          spids: [37242]
                                        )
                                      ]
                                      spids: [37242]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:RANLIB)
                                          op: Equal
                                          rhs: {(Lit_Other ":")}
                                          spids: [37246]
                                        )
                                      ]
                                      spids: [37246]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:objlist)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [37250]
                                        )
                                      ]
                                      spids: [37250]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:concat_cmds)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [37253]
                                        )
                                      ]
                                      spids: [37253]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:save_oldobjs)
                                          op: Equal
                                          rhs: {($ VSub_Name "$oldobjs")}
                                          spids: [37256]
                                        )
                                      ]
                                      spids: [37256]
                                    )
                                    (ForEach
                                      iter_name: obj
                                      iter_words: [{($ VSub_Name "$save_oldobjs")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:last_oldobj)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$obj")}
                                                  spids: [37277]
                                                )
                                              ]
                                              spids: [37277]
                                            )
                                          ]
                                          spids: [37274 37281]
                                        )
                                      spids: [37270 -1]
                                    )
                                    (ForEach
                                      iter_name: obj
                                      iter_words: [{($ VSub_Name "$save_oldobjs")}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:oldobjs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$objlist") (" ") 
                                                        ($ VSub_Name "$obj")
                                                      )
                                                    }
                                                  spids: [37296]
                                                )
                                              ]
                                              spids: [37296]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:objlist)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$objlist") (" ") 
                                                        ($ VSub_Name "$obj")
                                                      )
                                                    }
                                                  spids: [37304]
                                                )
                                              ]
                                              spids: [37304]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike "test_cmds=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$old_archive_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:len)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (SimpleCommand
                                                                                words: [
                                                                                  {(expr)}
                                                                                  {
                                                                                    (DQ (X) 
                                                                                      ($ VSub_Name 
"$test_cmds"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                  {(Lit_Other ":")}
                                                                                  {(DQ (".*"))}
                                                                                ]
                                                                                redirects: [
                                                                                  (Redir
                                                                                    op_id: 
Redir_Great
                                                                                    fd: 2
                                                                                    arg_word: 
                                                                                      {(/dev/null)}
                                                                                    spids: [37337]
                                                                                  )
                                                                                ]
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [37323 37339]
                                                                      )
                                                                    }
                                                                  spids: [37322]
                                                                )
                                                              ]
                                                              spids: [37322]
                                                            )
                                                            (C {(test)} {(DQ ($ VSub_Name "$len"))} 
                                                              {(-le)} {(DQ ($ VSub_Name "$max_cmd_len"))}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [(C {(Lit_Other ":")})]
                                                  spids: [-1 37357]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:oldobjs)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$objlist")}
                                                      spids: [37370]
                                                    )
                                                  ]
                                                  spids: [37370]
                                                )
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (Sentence
                                                          child: 
                                                            (C {(test)} {(DQ ($ VSub_Name "$obj"))} 
                                                              {(Lit_Other "=")} {(DQ ($ VSub_Name "$last_oldobj"))}
                                                            )
                                                          terminator: <Op_Semi ";">
                                                        )
                                                      ]
                                                      action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:RANLIB)
                                                              op: Equal
                                                              rhs: {($ VSub_Name "$save_RANLIB")}
                                                              spids: [37393]
                                                            )
                                                          ]
                                                          spids: [37393]
                                                        )
                                                      ]
                                                      spids: [-1 37390]
                                                    )
                                                  ]
                                                  spids: [-1 37397]
                                                )
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_Name "$concat_cmds"))}
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:concat_cmds)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_Name "$concat_cmds") 
                                                              (Lit_Tilde "~")
                                                            }
                                                          spids: [37410]
                                                        )
                                                      ]
                                                      spids: [37410]
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                                (C {(eval)} 
                                                  {(Lit_VarLike "concat_cmds=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (Lit_LBrace "{") (concat_cmds) (Lit_RBrace "}") 
                                                    ($ VSub_Name "$old_archive_cmds") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:objlist)
                                                      op: Equal
                                                      rhs: {(SQ )}
                                                      spids: [37427]
                                                    )
                                                  ]
                                                  spids: [37427]
                                                )
                                              ]
                                              spids: [37363 37430]
                                            )
                                          ]
                                          spids: [37293 37433]
                                        )
                                      spids: [37289 -1]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:RANLIB)
                                          op: Equal
                                          rhs: {($ VSub_Name "$save_RANLIB")}
                                          spids: [37436]
                                        )
                                      ]
                                      spids: [37436]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:oldobjs)
                                          op: Equal
                                          rhs: {($ VSub_Name "$objlist")}
                                          spids: [37440]
                                        )
                                      ]
                                      spids: [37440]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$oldobjs"))} 
                                                  {(Lit_Other "=")} {(DQ (X))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "cmds=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (concat_cmds) 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 37461]
                                        )
                                      ]
                                      else_action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike "cmds=") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (concat_cmds) (Lit_Tilde "~") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (old_archive_cmds) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                          }
                                        )
                                      ]
                                      spids: [37473 37488]
                                    )
                                  ]
                                  spids: [37228 37491]
                                )
                              ]
                              spids: [36690 37494]
                            )
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:save_ifs)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                      spids: [37497]
                                    )
                                  ]
                                  spids: [37497]
                                )
                              terminator: <Op_Semi ";">
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(SQ <"~">)}
                                  spids: [37503]
                                )
                              ]
                              spids: [37503]
                            )
                            (ForEach
                              iter_name: cmd
                              iter_words: [{($ VSub_Name "$cmds")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (C {(eval)} 
                                      {(Lit_VarLike "cmd=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [37529]
                                        )
                                      ]
                                      spids: [37529]
                                    )
                                    (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} {(DQ ($ VSub_Name "$cmd"))})
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [37518 37557]
                                )
                              spids: [37514 37516]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                  spids: [37560]
                                )
                              ]
                              spids: [37560]
                            )
                          ]
                          spids: [36514 37566]
                        )
                      spids: [36510 36512]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$generated"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$show")} 
                              {(DQ (${ VSub_Name rm) (r) ($ VSub_Name "$generated"))}
                            )
                            (C {($ VSub_Name "$run")} 
                              {(${ VSub_Name rm) (r) ($ VSub_Name "$generated")}
                            )
                          ]
                          spids: [-1 37581]
                        )
                      ]
                      spids: [-1 37604]
                    )
                    (Case
                      to_match: {($ VSub_Name "$output")}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.la)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:old_library)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [37624]
                                )
                              ]
                              spids: [37624]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} {(Lit_Other "=")} 
                                  {(yes)}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:old_library)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$libname") (.) ($ VSub_Name "$libext"))}
                                      spids: [37639]
                                    )
                                  ]
                                  spids: [37639]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (C {($ VSub_Name "$show")} {(DQ ("creating ") ($ VSub_Name "$output"))})
                            (ForEach
                              iter_name: var
                              iter_words: [{($ VSub_Name "$variables_saved_for_relink")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(eval)} {(test)} {(-z)} 
                                                  {
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (Lit_LBrace "{") ($ VSub_Name "$var") (Lit_Other "+") 
                                                    (set) (Lit_RBrace "}") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                  }
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:relink_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ("{ test -z ") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("{") ($ VSub_Name "$var") ("+set}") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) (" || unset ") ($ VSub_Name "$var") (" || { ") ($ VSub_Name "$var") ("=; export ") ($ VSub_Name "$var") 
                                                        ("; }; }; ") ($ VSub_Name "$relink_command")
                                                      )
                                                    }
                                                  spids: [37693]
                                                )
                                              ]
                                              spids: [37693]
                                            )
                                          ]
                                          spids: [-1 37690]
                                        )
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(eval)} 
                                                  {(Lit_VarLike "var_value=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ($ VSub_Name "$var")
                                                  }
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$var_value"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:relink_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$var") ("=; export ") 
                                                        ($ VSub_Name "$var") ("; ") ($ VSub_Name "$relink_command")
                                                      )
                                                    }
                                                  spids: [37734]
                                                )
                                              ]
                                              spids: [37734]
                                            )
                                          ]
                                          spids: [37713 37731]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:var_value)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {(DQ (X) ($ VSub_Name "$var_value"))}
                                                              )
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_Name "$sed_quote_subst")
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [37748 37765]
                                                  )
                                                }
                                              spids: [37747]
                                            )
                                          ]
                                          spids: [37747]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:relink_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$var") ("=") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\\"">
                                                    ) ($ VSub_Name "$var_value") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("; export ") 
                                                    ($ VSub_Name "$var") ("; ") ($ VSub_Name "$relink_command")
                                                  )
                                                }
                                              spids: [37768]
                                            )
                                          ]
                                          spids: [37768]
                                        )
                                      ]
                                      spids: [37744 37782]
                                    )
                                  ]
                                  spids: [37669 37785]
                                )
                              spids: [37665 37667]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ("(cd ") 
                                        (CommandSubPart
                                          command_list: (CommandList children:[(C {(pwd)})])
                                          left_token: <Left_Backtick "`">
                                          spids: [37795 37797]
                                        ) ("; ") ($ VSub_Name "$SHELL") (" ") ($ VSub_Name "$progpath") (" ") ($ VSub_Name "$preserve_args") 
                                        (" --mode=relink ") ($ VSub_Name "$libtool_args") (" @inst_prefix_dir@)")
                                      )
                                    }
                                  spids: [37792]
                                )
                              ]
                              spids: [37792]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$relink_command"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [37811 37828]
                                      )
                                    }
                                  spids: [37810]
                                )
                              ]
                              spids: [37810]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$hardcode_automatic"))} 
                                          {(Lit_Other "=")} {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [37848]
                                        )
                                      ]
                                      spids: [37848]
                                    )
                                  ]
                                  spids: [-1 37845]
                                )
                              ]
                              spids: [-1 37851]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (ForEach
                                      iter_name: installed
                                      iter_words: [{(no)} {(yes)}]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Name "$installed"))} 
                                                          {(Lit_Other "=")} {(yes)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$install_libdir")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (ControlFlow
                                                              token: <ControlFlow_Break break>
                                                            )
                                                          ]
                                                          spids: [-1 37915]
                                                        )
                                                      ]
                                                      spids: [-1 37921]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:output)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$output_objdir") (/) 
                                                                ($ VSub_Name "$outputname")
                                                              ) (i)
                                                            }
                                                          spids: [37924]
                                                        )
                                                      ]
                                                      spids: [37924]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdependency_libs)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [37937]
                                                        )
                                                      ]
                                                      spids: [37937]
                                                    )
                                                    (ForEach
                                                      iter_name: deplib
                                                      iter_words: [{($ VSub_Name "$dependency_libs")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Case
                                                              to_match: {($ VSub_Name "$deplib")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*") (.la)}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:name)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (CommandSubPart
                                                                                command_list: 
                                                                                  (CommandList
                                                                                    children: [
                                                                                      (Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$echo"
                                                                                              )
                                                                                            } {(DQ (X) ($ VSub_Name "$deplib"))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_Name "$Xsed"
                                                                                              )
                                                                                            } {(-e)} {(SQ <"s%^.*/%%">)}
                                                                                          )
                                                                                        ]
                                                                                        negated: 
False
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                                left_token: 
                                                                                  <Left_Backtick 
"`"
                                                                                  >
                                                                                spids: [37965 37982]
                                                                              )
                                                                            }
                                                                          spids: [37964]
                                                                        )
                                                                      ]
                                                                      spids: [37964]
                                                                    )
                                                                    (C {(eval)} 
                                                                      {(Lit_VarLike "libdir=") 
                                                                        (CommandSubPart
                                                                          command_list: 
                                                                            (CommandList
                                                                              children: [
                                                                                (C 
                                                                                  {
                                                                                    (${ VSub_Name SED)
                                                                                  } {(-n)} {(-e)} {(SQ <"s/^libdir=\\(.*\\)$/\\1/p">)} {($ VSub_Name "$deplib")}
                                                                                )
                                                                              ]
                                                                            )
                                                                          left_token: 
                                                                            <Left_Backtick "`">
                                                                          spids: [37988 38002]
                                                                        )
                                                                      }
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (C {(test)} {(-z)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ VSub_Name 
"$libdir"
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (SimpleCommand
                                                                              words: [
                                                                                {
                                                                                  ($ VSub_Name 
"$echo"
                                                                                  )
                                                                                }
                                                                                {
                                                                                  (DQ 
                                                                                    ($ VSub_Name 
"$modename"
                                                                                    ) (": ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$deplib") 
                                                                                    (
"' is not a valid libtool archive"
                                                                                    )
                                                                                  )
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (Redir
                                                                                  op_id: 
Redir_GreatAnd
                                                                                  fd: 1
                                                                                  arg_word: {(2)}
                                                                                  spids: [38029]
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {(exit)} 
                                                                              {
                                                                                ($ VSub_Name 
"$EXIT_FAILURE"
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                          spids: [-1 38016]
                                                                        )
                                                                      ]
                                                                      spids: [-1 38038]
                                                                    )
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: 
newdependency_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$newdependency_libs"
                                                                                ) (" ") ($ VSub_Name "$libdir") (/) ($ VSub_Name "$name")
                                                                              )
                                                                            }
                                                                          spids: [38041]
                                                                        )
                                                                      ]
                                                                      spids: [38041]
                                                                    )
                                                                  ]
                                                                  spids: [37959 37961 38051 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (LhsName
                                                                              name: 
newdependency_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$newdependency_libs"
                                                                                ) (" ") ($ VSub_Name "$deplib")
                                                                              )
                                                                            }
                                                                          spids: [38057]
                                                                        )
                                                                      ]
                                                                      spids: [38057]
                                                                    )
                                                                  ]
                                                                  spids: [38054 38055 38064 -1]
                                                                )
                                                              ]
                                                              spids: [37952 37956 38067]
                                                            )
                                                          ]
                                                          spids: [37949 38070]
                                                        )
                                                      spids: [37945 37947]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dependency_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$newdependency_libs"))
                                                            }
                                                          spids: [38073]
                                                        )
                                                      ]
                                                      spids: [38073]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdlfiles)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [38079]
                                                        )
                                                      ]
                                                      spids: [38079]
                                                    )
                                                    (ForEach
                                                      iter_name: lib
                                                      iter_words: [{($ VSub_Name "$dlfiles")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$lib"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} {(SQ <"s%^.*/%%">)}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [38095 38112]
                                                                      )
                                                                    }
                                                                  spids: [38094]
                                                                )
                                                              ]
                                                              spids: [38094]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "libdir=") 
                                                                (CommandSubPart
                                                                  command_list: 
                                                                    (CommandList
                                                                      children: [
                                                                        (C {(${ VSub_Name SED)} {(-n)} 
                                                                          {(-e)} {(SQ <"s/^libdir=\\(.*\\)$/\\1/p">)} {($ VSub_Name "$lib")}
                                                                        )
                                                                      ]
                                                                    )
                                                                  left_token: <Left_Backtick "`">
                                                                  spids: [38118 38132]
                                                                )
                                                              }
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name "$libdir")
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (SimpleCommand
                                                                      words: [
                                                                        {($ VSub_Name "$echo")}
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$modename") (": ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") 
                                                                            (
"' is not a valid libtool archive"
                                                                            )
                                                                          )
                                                                        }
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op_id: Redir_GreatAnd
                                                                          fd: 1
                                                                          arg_word: {(2)}
                                                                          spids: [38159]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(exit)} 
                                                                      {
                                                                        ($ VSub_Name "$EXIT_FAILURE")
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 38146]
                                                                )
                                                              ]
                                                              spids: [-1 38168]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:newdlfiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$newdlfiles") 
                                                                        (" ") ($ VSub_Name "$libdir") (/) ($ VSub_Name "$name")
                                                                      )
                                                                    }
                                                                  spids: [38171]
                                                                )
                                                              ]
                                                              spids: [38171]
                                                            )
                                                          ]
                                                          spids: [38091 38181]
                                                        )
                                                      spids: [38087 38089]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dlfiles)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$newdlfiles"))}
                                                          spids: [38184]
                                                        )
                                                      ]
                                                      spids: [38184]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:newdlprefiles)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [38190]
                                                        )
                                                      ]
                                                      spids: [38190]
                                                    )
                                                    (ForEach
                                                      iter_name: lib
                                                      iter_words: [{($ VSub_Name "$dlprefiles")}]
                                                      do_arg_iter: False
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$lib"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} {(SQ <"s%^.*/%%">)}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [38206 38223]
                                                                      )
                                                                    }
                                                                  spids: [38205]
                                                                )
                                                              ]
                                                              spids: [38205]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike "libdir=") 
                                                                (CommandSubPart
                                                                  command_list: 
                                                                    (CommandList
                                                                      children: [
                                                                        (C {(${ VSub_Name SED)} {(-n)} 
                                                                          {(-e)} {(SQ <"s/^libdir=\\(.*\\)$/\\1/p">)} {($ VSub_Name "$lib")}
                                                                        )
                                                                      ]
                                                                    )
                                                                  left_token: <Left_Backtick "`">
                                                                  spids: [38229 38243]
                                                                )
                                                              }
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name "$libdir")
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (SimpleCommand
                                                                      words: [
                                                                        {($ VSub_Name "$echo")}
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name "$modename") (": ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") 
                                                                            (
"' is not a valid libtool archive"
                                                                            )
                                                                          )
                                                                        }
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op_id: Redir_GreatAnd
                                                                          fd: 1
                                                                          arg_word: {(2)}
                                                                          spids: [38270]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(exit)} 
                                                                      {
                                                                        ($ VSub_Name "$EXIT_FAILURE")
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 38257]
                                                                )
                                                              ]
                                                              spids: [-1 38279]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:newdlprefiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_Name "$newdlprefiles") (" ") ($ VSub_Name "$libdir") (/) ($ VSub_Name "$name")
                                                                      )
                                                                    }
                                                                  spids: [38282]
                                                                )
                                                              ]
                                                              spids: [38282]
                                                            )
                                                          ]
                                                          spids: [38202 38292]
                                                        )
                                                      spids: [38198 38200]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:dlprefiles)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$newdlprefiles"))}
                                                          spids: [38295]
                                                        )
                                                      ]
                                                      spids: [38295]
                                                    )
                                                  ]
                                                  spids: [-1 37901]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:newdlfiles)
                                                      op: Equal
                                                      rhs: {(SQ )}
                                                      spids: [38304]
                                                    )
                                                  ]
                                                  spids: [38304]
                                                )
                                                (ForEach
                                                  iter_name: lib
                                                  iter_words: [{($ VSub_Name "$dlfiles")}]
                                                  do_arg_iter: False
                                                  body: 
                                                    (DoGroup
                                                      children: [
                                                        (Case
                                                          to_match: {($ VSub_Name "$lib")}
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "[") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\\">
                                                                  ) (/) (Lit_Other "]") (Lit_Other "*")
                                                                }
                                                                {(Lit_Other "[") (A-Za-z) 
                                                                  (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") 
                                                                  (Lit_Other "*")
                                                                }
                                                              ]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:abs)
                                                                      op: Equal
                                                                      rhs: {(DQ ($ VSub_Name "$lib"))}
                                                                      spids: [38345]
                                                                    )
                                                                  ]
                                                                  spids: [38345]
                                                                )
                                                              ]
                                                              spids: [38326 38343 38350 -1]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Other "*")}]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:abs)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (CommandSubPart
                                                                            command_list: 
                                                                              (CommandList
                                                                                children: [(C {(pwd)})]
                                                                              )
                                                                            left_token: 
                                                                              <Left_Backtick "`">
                                                                            spids: [38357 38359]
                                                                          ) (DQ (/) ($ VSub_Name "$lib"))
                                                                        }
                                                                      spids: [38356]
                                                                    )
                                                                  ]
                                                                  spids: [38356]
                                                                )
                                                              ]
                                                              spids: [38353 38354 38365 -1]
                                                            )
                                                          ]
                                                          spids: [38319 38323 38368]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdlfiles)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$newdlfiles") 
                                                                    (" ") ($ VSub_Name "$abs")
                                                                  )
                                                                }
                                                              spids: [38371]
                                                            )
                                                          ]
                                                          spids: [38371]
                                                        )
                                                      ]
                                                      spids: [38316 38379]
                                                    )
                                                  spids: [38312 38314]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dlfiles)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$newdlfiles"))}
                                                      spids: [38382]
                                                    )
                                                  ]
                                                  spids: [38382]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:newdlprefiles)
                                                      op: Equal
                                                      rhs: {(SQ )}
                                                      spids: [38388]
                                                    )
                                                  ]
                                                  spids: [38388]
                                                )
                                                (ForEach
                                                  iter_name: lib
                                                  iter_words: [{($ VSub_Name "$dlprefiles")}]
                                                  do_arg_iter: False
                                                  body: 
                                                    (DoGroup
                                                      children: [
                                                        (Case
                                                          to_match: {($ VSub_Name "$lib")}
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Other "[") 
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar "\\\\">
                                                                  ) (/) (Lit_Other "]") (Lit_Other "*")
                                                                }
                                                                {(Lit_Other "[") (A-Za-z) 
                                                                  (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) (Lit_Other "]") 
                                                                  (Lit_Other "*")
                                                                }
                                                              ]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:abs)
                                                                      op: Equal
                                                                      rhs: {(DQ ($ VSub_Name "$lib"))}
                                                                      spids: [38429]
                                                                    )
                                                                  ]
                                                                  spids: [38429]
                                                                )
                                                              ]
                                                              spids: [38410 38427 38434 -1]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Other "*")}]
                                                              action: [
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:abs)
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (CommandSubPart
                                                                            command_list: 
                                                                              (CommandList
                                                                                children: [(C {(pwd)})]
                                                                              )
                                                                            left_token: 
                                                                              <Left_Backtick "`">
                                                                            spids: [38441 38443]
                                                                          ) (DQ (/) ($ VSub_Name "$lib"))
                                                                        }
                                                                      spids: [38440]
                                                                    )
                                                                  ]
                                                                  spids: [38440]
                                                                )
                                                              ]
                                                              spids: [38437 38438 38449 -1]
                                                            )
                                                          ]
                                                          spids: [38403 38407 38452]
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:newdlprefiles)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$newdlprefiles") 
                                                                    (" ") ($ VSub_Name "$abs")
                                                                  )
                                                                }
                                                              spids: [38455]
                                                            )
                                                          ]
                                                          spids: [38455]
                                                        )
                                                      ]
                                                      spids: [38400 38463]
                                                    )
                                                  spids: [38396 38398]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:dlprefiles)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$newdlprefiles"))}
                                                      spids: [38466]
                                                    )
                                                  ]
                                                  spids: [38466]
                                                )
                                              ]
                                              spids: [38301 38472]
                                            )
                                            (C {($ VSub_Name "$rm")} {($ VSub_Name "$output")})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:tdlname)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$dlname")}
                                                  spids: [38484]
                                                )
                                              ]
                                              spids: [38484]
                                            )
                                            (Case
                                              to_match: 
                                                {($ VSub_Name "$host") (Lit_Comma ",") 
                                                  ($ VSub_Name "$output") (Lit_Comma ",") ($ VSub_Name "$installed") (Lit_Comma ",") ($ VSub_Name "$module") (Lit_Comma ",") 
                                                  ($ VSub_Name "$dlname")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (cygwin) (Lit_Other "*") 
                                                      (Lit_Comma ",") (Lit_Other "*") (lai) (Lit_Comma ",") (yes) (Lit_Comma ",") (no) (Lit_Comma ",") (Lit_Other "*") (.dll)
                                                    }
                                                    {(Lit_Other "*") (mingw) (Lit_Other "*") 
                                                      (Lit_Comma ",") (Lit_Other "*") (lai) (Lit_Comma ",") (yes) (Lit_Comma ",") (no) (Lit_Comma ",") (Lit_Other "*") (.dll)
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:tdlname)
                                                          op: Equal
                                                          rhs: {(../bin/) ($ VSub_Name "$dlname")}
                                                          spids: [38534]
                                                        )
                                                      ]
                                                      spids: [38534]
                                                    )
                                                  ]
                                                  spids: [38503 38532 38538 -1]
                                                )
                                              ]
                                              spids: [38488 38500 38541]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ("# ") ($ VSub_Name "$outputname") 
                                                    (" - a libtool library file\n") ("# Generated by ") ($ VSub_Name "$PROGRAM") (" - GNU ") ($ VSub_Name "$PACKAGE") (" ") 
                                                    ($ VSub_Name "$VERSION") ($ VSub_Name "$TIMESTAMP") ("\n") ("#\n") ("# Please DO NOT delete this file!\n") 
                                                    (
"# It is necessary for linking the library.\n"
                                                    ) ("\n") ("# The name that we can dlopen(3).\n") ("dlname='") ($ VSub_Name "$tdlname") ("'\n") ("\n") 
                                                    ("# Names of this library.\n") ("library_names='") ($ VSub_Name "$library_names") ("'\n") ("\n") ("# The name of the static archive.\n") 
                                                    ("old_library='") ($ VSub_Name "$old_library") ("'\n") ("\n") ("# Libraries that this one depends upon.\n") 
                                                    ("dependency_libs='") ($ VSub_Name "$dependency_libs") ("'\n") ("\n") ("# Version information for ") ($ VSub_Name "$libname") 
                                                    (".\n") ("current=") ($ VSub_Name "$current") ("\n") ("age=") ($ VSub_Name "$age") ("\n") ("revision=") 
                                                    ($ VSub_Name "$revision") ("\n") ("\n") ("# Is this an already installed library?\n") ("installed=") ($ VSub_Name "$installed") 
                                                    ("\n") ("\n") ("# Should we warn about portability when linking against -modules?\n") ("shouldnotlink=") 
                                                    ($ VSub_Name "$module") ("\n") ("\n") ("# Files to dlopen/dlpreopen\n") ("dlopen='") ($ VSub_Name "$dlfiles") ("'\n") 
                                                    ("dlpreopen='") ($ VSub_Name "$dlprefiles") ("'\n") ("\n") ("# Directory that this library needs to be installed in:\n") 
                                                    ("libdir='") ($ VSub_Name "$install_libdir") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$output")}
                                                  spids: [38546]
                                                )
                                              ]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$installed"))} {(Lit_Other "=")} {(no)}
                                                            )
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$need_relink"))} {(Lit_Other "=")} {(yes)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ("relink_command=") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\\"">
                                                            ) ($ VSub_Name "$relink_command") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_DGreat
                                                          fd: -1
                                                          arg_word: {($ VSub_Name "$output")}
                                                          spids: [38655]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [-1 38650]
                                                )
                                              ]
                                              spids: [-1 38668]
                                            )
                                          ]
                                          spids: [37885 38671]
                                        )
                                      spids: [37879 37883]
                                    )
                                  ]
                                  spids: [-1 37871]
                                )
                              ]
                              spids: [-1 38674]
                            )
                            (C {($ VSub_Name "$show")} 
                              {
                                (DQ ("(cd ") ($ VSub_Name "$output_objdir") (" && ") ($ VSub_Name "$rm") 
                                  (" ") ($ VSub_Name "$outputname") (" && ") ($ VSub_Name "$LN_S") (" ../") ($ VSub_Name "$outputname") (" ") 
                                  ($ VSub_Name "$outputname") (")")
                                )
                              }
                            )
                            (AndOr
                              children: [
                                (C {($ VSub_Name "$run")} {(eval)} 
                                  {
                                    (SQ 
                                      <
"(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
                                      >
                                    )
                                  }
                                )
                                (C {(exit)} {($ VSub_QMark "$?")})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [37619 37621 38720 -1]
                        )
                      ]
                      spids: [37612 37616 38723]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                  ]
                  spids: [6974 6979 38731 -1]
                )
                (case_arm
                  pat_list: [{(install)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": install"))}
                          spids: [38743]
                        )
                      ]
                      spids: [38743]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name "$nonopt"))} {(Lit_Other "=")} 
                                      {(DQ ($ VSub_Name "$SHELL"))}
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_Name "$nonopt"))} {(Lit_Other "=")} 
                                          {(/bin/sh)}
                                        )
                                        (Pipeline
                                          children: [
                                            (C {($ VSub_Name "$echo")} 
                                              {(DQ (X) ($ VSub_Name "$nonopt"))}
                                            )
                                            (SimpleCommand
                                              words: [{(grep)} {(shtool)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {(/dev/null)}
                                                  spids: [38805]
                                                )
                                              ]
                                            )
                                          ]
                                          negated: False
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:arg)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$nonopt"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [38818 38835]
                                      )
                                    }
                                  spids: [38817]
                                )
                              ]
                              spids: [38817]
                            )
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\[">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\^">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\(">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\}">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\<">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\'">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                    {(DQ )}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              )
                                            }
                                          spids: [38877]
                                        )
                                      ]
                                      spids: [38877]
                                    )
                                  ]
                                  spids: [38845 38874 38885 -1]
                                )
                              ]
                              spids: [38838 38842 38888]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:install_prog)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$arg") (" "))}
                                  spids: [38891]
                                )
                              ]
                              spids: [38891]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:arg)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [38898]
                                )
                              ]
                              spids: [38898]
                            )
                            (C {(shift)})
                          ]
                          spids: [-1 38810]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:install_prog)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [38910]
                            )
                          ]
                          spids: [38910]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:arg)
                              op: Equal
                              rhs: {($ VSub_Name "$nonopt")}
                              spids: [38913]
                            )
                          ]
                          spids: [38913]
                        )
                      ]
                      spids: [38907 38917]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:arg)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$arg"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                            {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [38930 38947]
                              )
                            }
                          spids: [38929]
                        )
                      ]
                      spids: [38929]
                    )
                    (Case
                      to_match: {($ VSub_Name "$arg")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (Lit_Other "[") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\[">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\^">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\(">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\}">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\<">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\'">
                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                              (Lit_Other "]") (Lit_Other "*")
                            }
                            {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                            {(DQ )}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:arg)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                        ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      )
                                    }
                                  spids: [38989]
                                )
                              ]
                              spids: [38989]
                            )
                          ]
                          spids: [38957 38986 38997 -1]
                        )
                      ]
                      spids: [38950 38954 39000]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:install_prog)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$install_prog") ($ VSub_Name "$arg"))}
                          spids: [39003]
                        )
                      ]
                      spids: [39003]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dest)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39015]
                        )
                      ]
                      spids: [39015]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:files)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39018]
                        )
                      ]
                      spids: [39018]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:opts)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39021]
                        )
                      ]
                      spids: [39021]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prev)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39024]
                        )
                      ]
                      spids: [39024]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:install_type)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39027]
                        )
                      ]
                      spids: [39027]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:isdir)
                          op: Equal
                          rhs: {(no)}
                          spids: [39030]
                        )
                      ]
                      spids: [39030]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stripme)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39034]
                        )
                      ]
                      spids: [39034]
                    )
                    (ForEach
                      iter_name: arg
                      do_arg_iter: True
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$dest"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:files)
                                          op: Equal
                                          rhs: 
                                            {(DQ ($ VSub_Name "$files") (" ") ($ VSub_Name "$dest"))}
                                          spids: [39059]
                                        )
                                      ]
                                      spids: [39059]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dest)
                                          op: Equal
                                          rhs: {($ VSub_Name "$arg")}
                                          spids: [39067]
                                        )
                                      ]
                                      spids: [39067]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [-1 39056]
                                )
                              ]
                              spids: [-1 39074]
                            )
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-d)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:isdir)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [39088]
                                        )
                                      ]
                                      spids: [39088]
                                    )
                                  ]
                                  spids: [39085 39086 39091 -1]
                                )
                                (case_arm
                                  pat_list: [{(-f)}]
                                  action: [
                                    (Case
                                      to_match: {(DQ (" ") ($ VSub_Name "$install_prog") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (Lit_Other "[") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (/) (Lit_Other "]") (cp) 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\ ">
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          spids: [39110 39119 39121 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$arg")}
                                                  spids: [39127]
                                                )
                                              ]
                                              spids: [39127]
                                            )
                                          ]
                                          spids: [39124 39125 39130 -1]
                                        )
                                      ]
                                      spids: [39099 39107 39133]
                                    )
                                  ]
                                  spids: [39094 39095 39136 -1]
                                )
                                (case_arm
                                  pat_list: [{(-g)} {(-m)} {(-o)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:prev)
                                          op: Equal
                                          rhs: {($ VSub_Name "$arg")}
                                          spids: [39150]
                                        )
                                      ]
                                      spids: [39150]
                                    )
                                  ]
                                  spids: [39139 39148 39153 -1]
                                )
                                (case_arm
                                  pat_list: [{(-s)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:stripme)
                                          op: Equal
                                          rhs: {(DQ (" -s"))}
                                          spids: [39160]
                                        )
                                      ]
                                      spids: [39160]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [39156 39157 39169 -1]
                                )
                                (case_arm
                                  pat_list: [{(-) (Lit_Other "*")}]
                                  spids: [39172 39174 39177 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prev"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prev)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [39202]
                                                )
                                              ]
                                              spids: [39202]
                                            )
                                          ]
                                          spids: [-1 39199]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:dest)
                                              op: Equal
                                              rhs: {($ VSub_Name "$arg")}
                                              spids: [39208]
                                            )
                                          ]
                                          spids: [39208]
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [39205 39215]
                                    )
                                  ]
                                  spids: [39180 39181 39218 -1]
                                )
                              ]
                              spids: [39078 39082 39221]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:arg)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$arg"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [39230 39247]
                                      )
                                    }
                                  spids: [39229]
                                )
                              ]
                              spids: [39229]
                            )
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (Lit_Other "[") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\[">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\~">) (EscapedLiteralPart token:<Lit_EscapedChar "\\#">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\^">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\&">) (EscapedLiteralPart token:<Lit_EscapedChar "\\*">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\(">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (EscapedLiteralPart token:<Lit_EscapedChar "\\{">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\}">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\|">) (EscapedLiteralPart token:<Lit_EscapedChar "\\;">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\<">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\>">) (EscapedLiteralPart token:<Lit_EscapedChar "\\?">) 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\'">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\t">) 
                                      (Lit_Other "]") (Lit_Other "*")
                                    }
                                    {(Lit_Other "*") (Lit_Other "]") (Lit_Other "*")}
                                    {(DQ )}
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:arg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                                ($ VSub_Name "$arg") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              )
                                            }
                                          spids: [39289]
                                        )
                                      ]
                                      spids: [39289]
                                    )
                                  ]
                                  spids: [39257 39286 39297 -1]
                                )
                              ]
                              spids: [39250 39254 39300]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:install_prog)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$install_prog") (" ") ($ VSub_Name "$arg"))}
                                  spids: [39303]
                                )
                              ]
                              spids: [39303]
                            )
                          ]
                          spids: [39042 39311]
                        )
                      spids: [-1 -1]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$install_prog"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") 
                                    (": you must specify an install program")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [39336]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [39346]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 39326]
                        )
                      ]
                      spids: [-1 39355]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$prev"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") (": the ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\`">
                                    ) ($ VSub_Name "$prev") ("' option requires an argument")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [39383]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [39393]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 39370]
                        )
                      ]
                      spids: [-1 39402]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$files"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$dest"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") 
                                            (": no file or destination specified")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [39441]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 39431]
                                )
                              ]
                              else_action: [
                                (SimpleCommand
                                  words: [
                                    {($ VSub_Name "$echo")}
                                    {
                                      (DQ ($ VSub_Name "$modename") 
                                        (": you must specify a destination")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 1
                                      arg_word: {(2)}
                                      spids: [39455]
                                    )
                                  ]
                                )
                              ]
                              spids: [39445 39459]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [39468]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 39417]
                        )
                      ]
                      spids: [-1 39477]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dest)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {($ VSub_Name "$echo")} {(DQ (X) ($ VSub_Name "$dest"))})
                                          (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%/$%%">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [39486 39503]
                              )
                            }
                          spids: [39485]
                        )
                      ]
                      spids: [39485]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-d)} {(DQ ($ VSub_Name "$dest"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:isdir)
                              op: Equal
                              rhs: {(yes)}
                              spids: [39521]
                            )
                          ]
                          spids: [39521]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Name "$isdir"))} {(Lit_Other "=")} {(yes)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destdir)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$dest"))}
                                  spids: [39541]
                                )
                              ]
                              spids: [39541]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destname)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [39547]
                                )
                              ]
                              spids: [39547]
                            )
                          ]
                          spids: [-1 39538]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:destdir)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (C {($ VSub_Name "$echo")} 
                                                {(DQ (X) ($ VSub_Name "$dest"))}
                                              )
                                              (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%/[^/]*$%%">)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [39554 39571]
                                  )
                                }
                              spids: [39553]
                            )
                          ]
                          spids: [39553]
                        )
                        (AndOr
                          children: [
                            (C {(test)} {(DQ (X) ($ VSub_Name "$destdir"))} {(Lit_Other "=")} 
                              {(DQ (X) ($ VSub_Name "$dest"))}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destdir)
                                  op: Equal
                                  rhs: {(.)}
                                  spids: [39590]
                                )
                              ]
                              spids: [39590]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:destname)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (C {($ VSub_Name "$echo")} 
                                                {(DQ (X) ($ VSub_Name "$dest"))}
                                              )
                                              (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [39595 39612]
                                  )
                                }
                              spids: [39594]
                            )
                          ]
                          spids: [39594]
                        )
                        (C {(set)} {(dummy)} {($ VSub_Name "$files")})
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-gt)} {(2)})
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (SimpleCommand
                                  words: [
                                    {($ VSub_Name "$echo")}
                                    {
                                      (DQ ($ VSub_Name "$modename") (": ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\`">
                                        ) ($ VSub_Name "$dest") ("' is not a directory")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 1
                                      arg_word: {(2)}
                                      spids: [39653]
                                    )
                                  ]
                                )
                                (SimpleCommand
                                  words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 1
                                      arg_word: {(2)}
                                      spids: [39663]
                                    )
                                  ]
                                )
                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                              ]
                              spids: [-1 39640]
                            )
                          ]
                          spids: [-1 39672]
                        )
                      ]
                      spids: [39550 39675]
                    )
                    (Case
                      to_match: {($ VSub_Name "$destdir")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "[") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/) 
                              (Lit_Other "]") (Lit_Other "*")
                            }
                            {(Lit_Other "[") (A-Za-z) (Lit_Other "]") (Lit_Other ":") (Lit_Other "[") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\\\">
                              ) (/) (Lit_Other "]") (Lit_Other "*")
                            }
                          ]
                          spids: [39685 39702 39704 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (ForEach
                              iter_name: file
                              iter_words: [{($ VSub_Name "$files")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {($ VSub_Name "$file")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.lo)}]
                                          spids: [39730 39732 39734 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") (": ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\`">
                                                    ) ($ VSub_Name "$destdir") ("' must be an absolute directory name")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [39751]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {(DQ ($ VSub_Name "$help"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [39761]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [39737 39738 39770 -1]
                                        )
                                      ]
                                      spids: [39723 39727 39773]
                                    )
                                  ]
                                  spids: [39720 39776]
                                )
                              spids: [39716 39718]
                            )
                          ]
                          spids: [39707 39708 39779 -1]
                        )
                      ]
                      spids: [39678 39682 39782]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libtool_install_magic)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$magic"))}
                          spids: [39794]
                        )
                      ]
                      spids: [39794]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:staticlibs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39801]
                        )
                      ]
                      spids: [39801]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:future_libdirs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39804]
                        )
                      ]
                      spids: [39804]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:current_libdirs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [39807]
                        )
                      ]
                      spids: [39807]
                    )
                    (ForEach
                      iter_name: file
                      iter_words: [{($ VSub_Name "$files")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$file")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$libext")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:staticlibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$staticlibs") (" ") 
                                                ($ VSub_Name "$file")
                                              )
                                            }
                                          spids: [39844]
                                        )
                                      ]
                                      spids: [39844]
                                    )
                                  ]
                                  spids: [39834 39837 39852 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.la)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$file")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [39890]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [39893]
                                                    )
                                                  ]
                                                  spids: [39867 39888]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 39897]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$file") ("' is not a valid libtool archive")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [39915]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [39925]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [39902 39934]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:library_names)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [39938]
                                        )
                                      ]
                                      spids: [39938]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:old_library)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [39941]
                                        )
                                      ]
                                      spids: [39941]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:relink_command)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [39944]
                                        )
                                      ]
                                      spids: [39944]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$file")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (/) (Lit_Other "*")}
                                            {(Lit_Other "*") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          action: [(C {(.)} {($ VSub_Name "$file")})]
                                          spids: [39958 39967 39973 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [(C {(.)} {(./) ($ VSub_Name "$file")})]
                                          spids: [39976 39977 39984 -1]
                                        )
                                      ]
                                      spids: [39951 39955 39987]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ (X) ($ VSub_Name "$destdir"))} 
                                                  {(Lit_Other "=")} {(DQ (X) ($ VSub_Name "$libdir"))}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$current_libdirs") (" "))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") 
                                                      (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                    }
                                                  ]
                                                  spids: [40025 40032 40034 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:current_libdirs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$current_libdirs") 
                                                                (" ") ($ VSub_Name "$libdir")
                                                              )
                                                            }
                                                          spids: [40040]
                                                        )
                                                      ]
                                                      spids: [40040]
                                                    )
                                                  ]
                                                  spids: [40037 40038 40047 -1]
                                                )
                                              ]
                                              spids: [40015 40022 40050]
                                            )
                                          ]
                                          spids: [-1 40012]
                                        )
                                      ]
                                      else_action: [
                                        (Case
                                          to_match: {(DQ ($ VSub_Name "$future_libdirs") (" "))}
                                          arms: [
                                            (case_arm
                                              pat_list: [
                                                {(Lit_Other "*") 
                                                  (DQ (" ") ($ VSub_Name "$libdir") (" ")) (Lit_Other "*")
                                                }
                                              ]
                                              spids: [40070 40077 40079 -1]
                                            )
                                            (case_arm
                                              pat_list: [{(Lit_Other "*")}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:future_libdirs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$future_libdirs") (" ") 
                                                            ($ VSub_Name "$libdir")
                                                          )
                                                        }
                                                      spids: [40085]
                                                    )
                                                  ]
                                                  spids: [40085]
                                                )
                                              ]
                                              spids: [40082 40083 40092 -1]
                                            )
                                          ]
                                          spids: [40060 40067 40095]
                                        )
                                      ]
                                      spids: [40053 40098]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$file"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%/[^/]*$%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [40103 40120]
                                              ) (/)
                                            }
                                          spids: [40102]
                                        )
                                      ]
                                      spids: [40102]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$dir"))} {(Lit_Other "=")} 
                                          {(DQ (X) ($ VSub_Name "$file") (/))}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:dir)
                                              op: Equal
                                              rhs: {(SQ )}
                                              spids: [40141]
                                            )
                                          ]
                                          spids: [40141]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$dir") ($ VSub_Name "$objdir"))}
                                          spids: [40144]
                                        )
                                      ]
                                      spids: [40144]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$relink_command"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:inst_prefix_dir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ ($ VSub_Name "$destdir"))}
                                                                  )
                                                                  (C {($ VSub_Name "$SED")} 
                                                                    {
                                                                      (DQ ("s%") 
                                                                        ($ VSub_Name "$libdir") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("%%")
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [40171 40188]
                                                      )
                                                    }
                                                  spids: [40170]
                                                )
                                              ]
                                              spids: [40170]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_Name "$inst_prefix_dir"))} {(Lit_Other "=")} {(DQ ($ VSub_Name "$destdir"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": error: cannot install ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$file") 
                                                            ("' to a directory not ending in ") ($ VSub_Name "$libdir")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [40245]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 40231]
                                                )
                                              ]
                                              spids: [-1 40254]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$inst_prefix_dir"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:relink_command)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$relink_command"
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$SED")} 
                                                                            {
                                                                              (DQ 
                                                                                (
"s%@inst_prefix_dir@%-inst-prefix-dir "
                                                                                ) ($ VSub_Name "$inst_prefix_dir") ("%")
                                                                              )
                                                                            }
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [40277 40293]
                                                              )
                                                            }
                                                          spids: [40276]
                                                        )
                                                      ]
                                                      spids: [40276]
                                                    )
                                                  ]
                                                  spids: [-1 40269]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:relink_command)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (Pipeline
                                                                    children: [
                                                                      (C {($ VSub_Name "$echo")} 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
"$relink_command"
                                                                            )
                                                                          )
                                                                        }
                                                                      )
                                                                      (C {($ VSub_Name "$SED")} 
                                                                        {
                                                                          (DQ 
                                                                            (
"s%@inst_prefix_dir@%%"
                                                                            )
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: False
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [40300 40314]
                                                          )
                                                        }
                                                      spids: [40299]
                                                    )
                                                  ]
                                                  spids: [40299]
                                                )
                                              ]
                                              spids: [40296 40317]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": warning: relinking ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$file") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [40331]
                                                )
                                              ]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {(DQ ($ VSub_Name "$relink_command"))}
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {(DQ ($ VSub_Name "$relink_command"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [(C {(Lit_Other ":")})]
                                                  spids: [-1 40353]
                                                )
                                              ]
                                              else_action: [
                                                (SimpleCommand
                                                  words: [
                                                    {($ VSub_Name "$echo")}
                                                    {
                                                      (DQ ($ VSub_Name "$modename") 
                                                        (": error: relink ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$file") 
                                                        (
"' with the above command before installing it"
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 1
                                                      arg_word: {(2)}
                                                      spids: [40371]
                                                    )
                                                  ]
                                                )
                                                (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                              ]
                                              spids: [40358 40380]
                                            )
                                          ]
                                          spids: [-1 40163]
                                        )
                                      ]
                                      spids: [-1 40383]
                                    )
                                    (C {(set)} {(dummy)} {($ VSub_Name "$library_names")})
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Number "$2"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:realname)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Number "$2"))}
                                                  spids: [40412]
                                                )
                                              ]
                                              spids: [40412]
                                            )
                                            (C {(shift)})
                                            (C {(shift)})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:srcname)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$realname"))}
                                                  spids: [40425]
                                                )
                                              ]
                                              spids: [40425]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$relink_command"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:srcname)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$realname")) (T)}
                                                      spids: [40441]
                                                    )
                                                  ]
                                                  spids: [40441]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$install_prog") (" ") 
                                                  ($ VSub_Name "$dir") (/) ($ VSub_Name "$srcname") (" ") ($ VSub_Name "$destdir") (/) ($ VSub_Name "$realname")
                                                )
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (DQ ($ VSub_Name "$install_prog") (" ") 
                                                      ($ VSub_Name "$dir") (/) ($ VSub_Name "$srcname") (" ") ($ VSub_Name "$destdir") (/) ($ VSub_Name "$realname")
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$stripme"))}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$striplib"))}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_Name "$show")} 
                                                      {
                                                        (DQ ($ VSub_Name "$striplib") (" ") 
                                                          ($ VSub_Name "$destdir") (/) ($ VSub_Name "$realname")
                                                        )
                                                      }
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {
                                                            (DQ ($ VSub_Name "$striplib") (" ") 
                                                              ($ VSub_Name "$destdir") (/) ($ VSub_Name "$realname")
                                                            )
                                                          }
                                                        )
                                                        (C {(exit)} {($ VSub_QMark "$?")})
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  ]
                                                  spids: [-1 40512]
                                                )
                                              ]
                                              spids: [-1 40545]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-gt)} 
                                                          {(0)}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (ForEach
                                                      iter_name: linkname
                                                      do_arg_iter: True
                                                      body: 
                                                        (DoGroup
                                                          children: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_Name 
"$linkname"
                                                                              )
                                                                            )
                                                                          } {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$realname"))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_Name "$show")} 
                                                                      {
                                                                        (DQ ("(cd ") 
                                                                          ($ VSub_Name "$destdir") (" && { ") ($ VSub_Name "$LN_S") (" -f ") ($ VSub_Name "$realname") (" ") ($ VSub_Name "$linkname") 
                                                                          (" || { ") ($ VSub_Name "$rm") (" ") ($ VSub_Name "$linkname") (" && ") ($ VSub_Name "$LN_S") (" ") 
                                                                          ($ VSub_Name "$realname") (" ") ($ VSub_Name "$linkname") ("; }; })")
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {
                                                                        (DQ ("(cd ") 
                                                                          ($ VSub_Name "$destdir") (" && { ") ($ VSub_Name "$LN_S") (" -f ") ($ VSub_Name "$realname") (" ") ($ VSub_Name "$linkname") 
                                                                          (" || { ") ($ VSub_Name "$rm") (" ") ($ VSub_Name "$linkname") (" && ") ($ VSub_Name "$LN_S") (" ") 
                                                                          ($ VSub_Name "$realname") (" ") ($ VSub_Name "$linkname") ("; }; })")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 40605]
                                                                )
                                                              ]
                                                              spids: [-1 40660]
                                                            )
                                                          ]
                                                          spids: [40586 40663]
                                                        )
                                                      spids: [-1 -1]
                                                    )
                                                  ]
                                                  spids: [-1 40562]
                                                )
                                              ]
                                              spids: [-1 40666]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:lib)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$destdir") (/) 
                                                        ($ VSub_Name "$realname")
                                                      )
                                                    }
                                                  spids: [40674]
                                                )
                                              ]
                                              spids: [40674]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$postinstall_cmds")}
                                                  spids: [40682]
                                                )
                                              ]
                                              spids: [40682]
                                            )
                                            (Sentence
                                              child: 
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:save_ifs)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                      spids: [40686]
                                                    )
                                                  ]
                                                  spids: [40686]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(SQ <"~">)}
                                                  spids: [40692]
                                                )
                                              ]
                                              spids: [40692]
                                            )
                                            (ForEach
                                              iter_name: cmd
                                              iter_words: [{($ VSub_Name "$cmds")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                          spids: [40710]
                                                        )
                                                      ]
                                                      spids: [40710]
                                                    )
                                                    (C {(eval)} 
                                                      {(Lit_VarLike "cmd=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$show")} 
                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {(DQ ($ VSub_Name "$cmd"))}
                                                        )
                                                        (BraceGroup
                                                          children: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:lt_exit)
                                                                  op: Equal
                                                                  rhs: {($ VSub_QMark "$?")}
                                                                  spids: [40744]
                                                                )
                                                              ]
                                                              spids: [40744]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(test)} 
                                                                          {
                                                                            (DQ ($ VSub_Name "$mode"))
                                                                          } {(Lit_Other "=")} {(relink)}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {
                                                                        (SQ 
                                                                          <
"(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)"
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 40766]
                                                                )
                                                              ]
                                                              spids: [-1 40778]
                                                            )
                                                            (C {(exit)} {($ VSub_Name "$lt_exit")})
                                                          ]
                                                          spids: [40741]
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  ]
                                                  spids: [40707 40790]
                                                )
                                              spids: [40703 40705]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [40793]
                                                )
                                              ]
                                              spids: [40793]
                                            )
                                          ]
                                          spids: [-1 40409]
                                        )
                                      ]
                                      spids: [-1 40799]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:name)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$file"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%^.*/%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [40808 40825]
                                              )
                                            }
                                          spids: [40807]
                                        )
                                      ]
                                      spids: [40807]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:instname)
                                          op: Equal
                                          rhs: 
                                            {(DQ ($ VSub_Name "$dir") (/) ($ VSub_Name "$name")) (i)}
                                          spids: [40828]
                                        )
                                      ]
                                      spids: [40828]
                                    )
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$install_prog") (" ") 
                                          ($ VSub_Name "$instname") (" ") ($ VSub_Name "$destdir") (/) ($ VSub_Name "$name")
                                        )
                                      }
                                    )
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {
                                            (DQ ($ VSub_Name "$install_prog") (" ") 
                                              ($ VSub_Name "$instname") (" ") ($ VSub_Name "$destdir") (/) ($ VSub_Name "$name")
                                            )
                                          }
                                        )
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$old_library"))})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:staticlibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$staticlibs") (" ") 
                                                    ($ VSub_Name "$dir") (/) ($ VSub_Name "$old_library")
                                                  )
                                                }
                                              spids: [40886]
                                            )
                                          ]
                                          spids: [40886]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  spids: [39856 39858 40896 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.lo)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$destname"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:destfile)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$destdir") (/) 
                                                        ($ VSub_Name "$destname")
                                                      )
                                                    }
                                                  spids: [40928]
                                                )
                                              ]
                                              spids: [40928]
                                            )
                                          ]
                                          spids: [-1 40925]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:destfile)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {(DQ (X) ($ VSub_Name "$file"))}
                                                              )
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {(SQ <"s%^.*/%%">)}
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [40940 40957]
                                                  )
                                                }
                                              spids: [40939]
                                            )
                                          ]
                                          spids: [40939]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:destfile)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$destdir") (/) 
                                                    ($ VSub_Name "$destfile")
                                                  )
                                                }
                                              spids: [40960]
                                            )
                                          ]
                                          spids: [40960]
                                        )
                                      ]
                                      spids: [40936 40968]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$destfile")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.lo)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:staticdest)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {
                                                                      (DQ (X) 
                                                                        ($ VSub_Name "$destfile")
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ($ VSub_Name "$lo2o"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [40989 41006]
                                                      )
                                                    }
                                                  spids: [40988]
                                                )
                                              ]
                                              spids: [40988]
                                            )
                                          ]
                                          spids: [40983 40985 41009 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.) ($ VSub_Name "$objext")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:staticdest)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$destfile"))}
                                                  spids: [41018]
                                                )
                                              ]
                                              spids: [41018]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:destfile)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [41024]
                                                )
                                              ]
                                              spids: [41024]
                                            )
                                          ]
                                          spids: [41012 41015 41027 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {
                                                  (DQ ($ VSub_Name "$modename") 
                                                    (": cannot copy a libtool object to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$destfile") ("'")
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [41044]
                                                )
                                              ]
                                            )
                                            (SimpleCommand
                                              words: [
                                                {($ VSub_Name "$echo")}
                                                {(DQ ($ VSub_Name "$help"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 1
                                                  arg_word: {(2)}
                                                  spids: [41054]
                                                )
                                              ]
                                            )
                                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                          ]
                                          spids: [41030 41031 41063 -1]
                                        )
                                      ]
                                      spids: [40976 40980 41066]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$destfile"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$install_prog") (" ") 
                                                  ($ VSub_Name "$file") (" ") ($ VSub_Name "$destfile")
                                                )
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (DQ ($ VSub_Name "$install_prog") (" ") 
                                                      ($ VSub_Name "$file") (" ") ($ VSub_Name "$destfile")
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 41085]
                                        )
                                      ]
                                      spids: [-1 41118]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$build_old_libs"))} 
                                                  {(Lit_Other "=")} {(yes)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:staticobj)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {(DQ (X) ($ VSub_Name "$file"))}
                                                                  )
                                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                    {(DQ ($ VSub_Name "$lo2o"))}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [41147 41164]
                                                      )
                                                    }
                                                  spids: [41146]
                                                )
                                              ]
                                              spids: [41146]
                                            )
                                            (C {($ VSub_Name "$show")} 
                                              {
                                                (DQ ($ VSub_Name "$install_prog") (" ") 
                                                  ($ VSub_Name "$staticobj") (" ") ($ VSub_Name "$staticdest")
                                                )
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {
                                                    (DQ ($ VSub_Name "$install_prog") (" ") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\$">
                                                      ) ("staticobj ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (staticdest)
                                                    )
                                                  }
                                                )
                                                (C {(exit)} {($ VSub_QMark "$?")})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 41139]
                                        )
                                      ]
                                      spids: [-1 41199]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                                  ]
                                  spids: [40900 40902 41207 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$destname"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:destfile)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$destdir") (/) 
                                                        ($ VSub_Name "$destname")
                                                      )
                                                    }
                                                  spids: [41233]
                                                )
                                              ]
                                              spids: [41233]
                                            )
                                          ]
                                          spids: [-1 41230]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:destfile)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {($ VSub_Name "$echo")} 
                                                                {(DQ (X) ($ VSub_Name "$file"))}
                                                              )
                                                              (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                {(SQ <"s%^.*/%%">)}
                                                              )
                                                            ]
                                                            negated: False
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick "`">
                                                    spids: [41245 41262]
                                                  )
                                                }
                                              spids: [41244]
                                            )
                                          ]
                                          spids: [41244]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:destfile)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_Name "$destdir") (/) 
                                                    ($ VSub_Name "$destfile")
                                                  )
                                                }
                                              spids: [41265]
                                            )
                                          ]
                                          spids: [41265]
                                        )
                                      ]
                                      spids: [41241 41273]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:stripped_ext)
                                          op: Equal
                                          rhs: {(DQ )}
                                          spids: [41289]
                                        )
                                      ]
                                      spids: [41289]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$file")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Other "*") (.exe)}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(KW_Bang "!")} {(-f)} 
                                                          {(DQ ($ VSub_Name "$file"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:file)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {($ VSub_Name "$file")}
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(SQ <"s,.exe$,,">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [41323 41335]
                                                              )
                                                            }
                                                          spids: [41322]
                                                        )
                                                      ]
                                                      spids: [41322]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:stripped_ext)
                                                          op: Equal
                                                          rhs: {(DQ (.exe))}
                                                          spids: [41338]
                                                        )
                                                      ]
                                                      spids: [41338]
                                                    )
                                                  ]
                                                  spids: [-1 41319]
                                                )
                                              ]
                                              spids: [-1 41344]
                                            )
                                          ]
                                          spids: [41301 41303 41347 -1]
                                        )
                                      ]
                                      spids: [41294 41298 41350]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$host")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (cygwin) (Lit_Other "*")}
                                            {(Lit_Other "*") (mingw) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:wrapper)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (Pipeline
                                                                children: [
                                                                  (C {($ VSub_Name "$echo")} 
                                                                    {($ VSub_Name "$file")}
                                                                  )
                                                                  (C {(${ VSub_Name SED)} {(-e)} 
                                                                    {(SQ <"s,.exe$,,">)}
                                                                  )
                                                                ]
                                                                negated: False
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_Backtick "`">
                                                        spids: [41376 41392]
                                                      )
                                                    }
                                                  spids: [41375]
                                                )
                                              ]
                                              spids: [41375]
                                            )
                                          ]
                                          spids: [41365 41372 41395 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:wrapper)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$file")}
                                                  spids: [41402]
                                                )
                                              ]
                                              spids: [41402]
                                            )
                                          ]
                                          spids: [41398 41399 41406 -1]
                                        )
                                      ]
                                      spids: [41358 41362 41409]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <4q>)} 
                                                          {($ VSub_Name "$wrapper")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [41436]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [41439]
                                                    )
                                                  ]
                                                  spids: [41414 41435]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:notinst_deplibs)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [41446]
                                                )
                                              ]
                                              spids: [41446]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:relink_command)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [41449]
                                                )
                                              ]
                                              spids: [41449]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$wrapper")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (/) (Lit_Other "*")}
                                                    {(Lit_Other "*") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [(C {(.)} {(${ VSub_Name wrapper)})]
                                                  spids: [41484 41493 41501 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [(C {(.)} {(./) (${ VSub_Name wrapper)})]
                                                  spids: [41504 41505 41514 -1]
                                                )
                                              ]
                                              spids: [41477 41481 41517]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_Name "$notinst_deplibs"))}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$echo")}
                                                        {
                                                          (DQ ($ VSub_Name "$modename") 
                                                            (": invalid libtool wrapper script ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$wrapper") ("'")
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 1
                                                          arg_word: {(2)}
                                                          spids: [41549]
                                                        )
                                                      ]
                                                    )
                                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                                  ]
                                                  spids: [-1 41536]
                                                )
                                              ]
                                              spids: [-1 41558]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:finalize)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [41562]
                                                )
                                              ]
                                              spids: [41562]
                                            )
                                            (ForEach
                                              iter_name: lib
                                              iter_words: [{($ VSub_Name "$notinst_deplibs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libdir)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [41582]
                                                        )
                                                      ]
                                                      spids: [41582]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {(DQ ($ VSub_Name "$lib"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Case
                                                              to_match: {($ VSub_Name "$lib")}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Other "*") (/) 
                                                                      (Lit_Other "*")
                                                                    }
                                                                    {(Lit_Other "*") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\\\">
                                                                      ) (Lit_Other "*")
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (C {(.)} {($ VSub_Name "$lib")})
                                                                  ]
                                                                  spids: [41610 41619 41625 -1]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Other "*")}]
                                                                  action: [
                                                                    (C {(.)} 
                                                                      {(./) ($ VSub_Name "$lib")}
                                                                    )
                                                                  ]
                                                                  spids: [41628 41629 41636 -1]
                                                                )
                                                              ]
                                                              spids: [41603 41607 41639]
                                                            )
                                                          ]
                                                          spids: [-1 41596]
                                                        )
                                                      ]
                                                      spids: [-1 41642]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:libfile)
                                                          op: Equal
                                                          rhs: 
                                                            {(DQ ($ VSub_Name "$libdir") (/)) 
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              (DQ (X) 
                                                                                ($ VSub_Name "$lib")
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {($ VSub_Name "$Xsed")} 
                                                                            {(-e)} {(SQ <"s%^.*/%%g">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [41650 41667]
                                                              )
                                                            }
                                                          spids: [41645]
                                                        )
                                                      ]
                                                      spids: [41645]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} {(-n)} 
                                                                      {(DQ ($ VSub_Name "$libdir"))}
                                                                    )
                                                                    (C {(test)} {(KW_Bang "!")} {(-f)} 
                                                                      {(DQ ($ VSub_Name "$libfile"))}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (SimpleCommand
                                                              words: [
                                                                {($ VSub_Name "$echo")}
                                                                {
                                                                  (DQ ($ VSub_Name "$modename") 
                                                                    (": warning: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$lib") 
                                                                    (
"' has not been installed in "
                                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$libdir") ("'")
                                                                  )
                                                                }
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op_id: Redir_GreatAnd
                                                                  fd: 1
                                                                  arg_word: {(2)}
                                                                  spids: [41712]
                                                                )
                                                              ]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:finalize)
                                                                  op: Equal
                                                                  rhs: {(no)}
                                                                  spids: [41716]
                                                                )
                                                              ]
                                                              spids: [41716]
                                                            )
                                                          ]
                                                          spids: [-1 41696]
                                                        )
                                                      ]
                                                      spids: [-1 41720]
                                                    )
                                                  ]
                                                  spids: [41575 41723]
                                                )
                                              spids: [41571 41573]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:relink_command)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [41727]
                                                )
                                              ]
                                              spids: [41727]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$wrapper")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (/) (Lit_Other "*")}
                                                    {(Lit_Other "*") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [(C {(.)} {(${ VSub_Name wrapper)})]
                                                  spids: [41761 41770 41778 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [(C {(.)} {(./) (${ VSub_Name wrapper)})]
                                                  spids: [41781 41782 41791 -1]
                                                )
                                              ]
                                              spids: [41754 41758 41794]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:outputname)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [41798]
                                                )
                                              ]
                                              spids: [41798]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$fast_install"))} {(Lit_Other "=")} {(no)}
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$relink_command"))}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ ($ VSub_Name "$finalize"))
                                                                      } {(Lit_Other "=")} {(yes)}
                                                                    )
                                                                    (C {(test)} {(-z)} 
                                                                      {(DQ ($ VSub_Name "$run"))}
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:tmpdir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (C {(func_mktempdir)})
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [41854 41856]
                                                                      )
                                                                    }
                                                                  spids: [41853]
                                                                )
                                                              ]
                                                              spids: [41853]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:file)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$file") ($ VSub_Name "$stripped_ext"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} {(SQ <"s%^.*/%%">)}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [41860 41878]
                                                                      )
                                                                    }
                                                                  spids: [41859]
                                                                )
                                                              ]
                                                              spids: [41859]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:outputname)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$tmpdir") (/) 
                                                                        ($ VSub_Name "$file")
                                                                      )
                                                                    }
                                                                  spids: [41881]
                                                                )
                                                              ]
                                                              spids: [41881]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:relink_command)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$echo"
                                                                                      )
                                                                                    } {(DQ (X) ($ VSub_Name "$relink_command"))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ VSub_Name 
"$Xsed"
                                                                                      )
                                                                                    } {(-e)} {(SQ <"s%@OUTPUT@%">) (DQ ($ VSub_Name "$outputname")) (SQ <"%g">)}
                                                                                  )
                                                                                ]
                                                                                negated: False
                                                                              )
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_Backtick "`">
                                                                        spids: [41894 41917]
                                                                      )
                                                                    }
                                                                  spids: [41893]
                                                                )
                                                              ]
                                                              spids: [41893]
                                                            )
                                                            (C {($ VSub_Name "$show")} 
                                                              {(DQ ($ VSub_Name "$relink_command"))}
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {($ VSub_Name "$run")} 
                                                                          {(eval)} {(DQ ($ VSub_Name "$relink_command"))}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [(C {(Lit_Other ":")})]
                                                                  spids: [-1 41939]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (SimpleCommand
                                                                  words: [
                                                                    {($ VSub_Name "$echo")}
                                                                    {
                                                                      (DQ ($ VSub_Name "$modename") 
                                                                        (": error: relink ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$file") 
                                                                        (
"' with the above command before installing it"
                                                                        )
                                                                      )
                                                                    }
                                                                  ]
                                                                  redirects: [
                                                                    (Redir
                                                                      op_id: Redir_GreatAnd
                                                                      fd: 1
                                                                      arg_word: {(2)}
                                                                      spids: [41957]
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(${ VSub_Name rm) (r)} 
                                                                  {(DQ ($ VSub_Name "$tmpdir"))}
                                                                )
                                                                (ControlFlow
                                                                  token: 
                                                                    <ControlFlow_Continue continue>
                                                                )
                                                              ]
                                                              spids: [41944 41974]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:file)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$outputname"))
                                                                    }
                                                                  spids: [41977]
                                                                )
                                                              ]
                                                              spids: [41977]
                                                            )
                                                          ]
                                                          spids: [-1 41850]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (SimpleCommand
                                                          words: [
                                                            {($ VSub_Name "$echo")}
                                                            {
                                                              (DQ ($ VSub_Name "$modename") 
                                                                (": warning: cannot relink ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$file") ("'")
                                                              )
                                                            }
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_GreatAnd
                                                              fd: 1
                                                              arg_word: {(2)}
                                                              spids: [41996]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      spids: [41983 42000]
                                                    )
                                                  ]
                                                  spids: [-1 41824]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:file)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (Pipeline
                                                                    children: [
                                                                      (C {($ VSub_Name "$echo")} 
                                                                        {
                                                                          (DQ (X) 
                                                                            ($ VSub_Name "$file") ($ VSub_Name "$stripped_ext")
                                                                          )
                                                                        }
                                                                      )
                                                                      (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                                        {
                                                                          (DQ ("s%") 
                                                                            (EscapedLiteralPart
                                                                              token: 
                                                                                <Lit_EscapedChar 
"\\("
                                                                                >
                                                                            ) ("[^/]*") (EscapedLiteralPart token:<Lit_EscapedChar "\\)">) (Lit_Other "$") ("%") 
                                                                            ($ VSub_Name "$objdir") (/) (EscapedLiteralPart token:<Lit_EscapedChar "\\1">) ("%")
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: False
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_Backtick "`">
                                                            spids: [42011 42038]
                                                          )
                                                        }
                                                      spids: [42010]
                                                    )
                                                  ]
                                                  spids: [42010]
                                                )
                                              ]
                                              spids: [42003 42041]
                                            )
                                          ]
                                          spids: [-1 41443]
                                        )
                                      ]
                                      spids: [-1 42044]
                                    )
                                    (Case
                                      to_match: 
                                        {($ VSub_Name "$install_prog") (Lit_Comma ",") 
                                          ($ VSub_Name "$host")
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (/usr/bin/install) (Lit_Other "*") 
                                              (Lit_Comma ",") (Lit_Other "*") (cygwin) (Lit_Other "*")
                                            }
                                          ]
                                          action: [
                                            (Case
                                              to_match: 
                                                {($ VSub_Name "$file") (Lit_Other ":") 
                                                  ($ VSub_Name "$destfile")
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (.exe) (Lit_Other ":") 
                                                      (Lit_Other "*") (.exe)
                                                    }
                                                  ]
                                                  spids: [42084 42089 42096 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (.exe) (Lit_Other ":") 
                                                      (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:destfile)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$destfile") (.exe)}
                                                          spids: [42106]
                                                        )
                                                      ]
                                                      spids: [42106]
                                                    )
                                                  ]
                                                  spids: [42099 42103 42111 -1]
                                                )
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (Lit_Other ":") (Lit_Other "*") 
                                                      (.exe)
                                                    }
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:destfile)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {
                                                                              ($ VSub_Name 
"$destfile"
                                                                              )
                                                                            }
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(-e)} {(SQ <"s,.exe$,,">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [42122 42138]
                                                              )
                                                            }
                                                          spids: [42121]
                                                        )
                                                      ]
                                                      spids: [42121]
                                                    )
                                                  ]
                                                  spids: [42114 42118 42141 -1]
                                                )
                                              ]
                                              spids: [42075 42081 42144]
                                            )
                                          ]
                                          spids: [42065 42072 42147 -1]
                                        )
                                      ]
                                      spids: [42056 42062 42150]
                                    )
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$install_prog") ($ VSub_Name "$stripme") 
                                          (" ") ($ VSub_Name "$file") (" ") ($ VSub_Name "$destfile")
                                        )
                                      }
                                    )
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {
                                            (DQ ($ VSub_Name "$install_prog") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\$">
                                              ) ("stripme ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("file ") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\$">
                                              ) (destfile)
                                            )
                                          }
                                        )
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$outputname"))})
                                        (C {(${ VSub_Name rm) (r)} {(DQ ($ VSub_Name "$tmpdir"))})
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  spids: [41211 41212 42206 -1]
                                )
                              ]
                              spids: [39827 39831 42209]
                            )
                          ]
                          spids: [39819 42212]
                        )
                      spids: [39815 39817]
                    )
                    (ForEach
                      iter_name: file
                      iter_words: [{($ VSub_Name "$staticlibs")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$file"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [42229 42246]
                                      )
                                    }
                                  spids: [42228]
                                )
                              ]
                              spids: [42228]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:oldlib)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$destdir") (/) ($ VSub_Name "$name"))}
                                  spids: [42254]
                                )
                              ]
                              spids: [42254]
                            )
                            (C {($ VSub_Name "$show")} 
                              {
                                (DQ ($ VSub_Name "$install_prog") (" ") ($ VSub_Name "$file") (" ") 
                                  ($ VSub_Name "$oldlib")
                                )
                              }
                            )
                            (AndOr
                              children: [
                                (C {($ VSub_Name "$run")} {(eval)} 
                                  {
                                    (DQ ($ VSub_Name "$install_prog") (" ") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\$">
                                      ) ("file ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (oldlib)
                                    )
                                  }
                                )
                                (C {(exit)} {($ VSub_QMark "$?")})
                              ]
                              op_id: Op_DPipe
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$stripme"))})
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$old_striplib"))})
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} 
                                      {
                                        (DQ ($ VSub_Name "$old_striplib") (" ") ($ VSub_Name "$oldlib"))
                                      }
                                    )
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} 
                                          {
                                            (DQ ($ VSub_Name "$old_striplib") (" ") 
                                              ($ VSub_Name "$oldlib")
                                            )
                                          }
                                        )
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [-1 42316]
                                )
                              ]
                              spids: [-1 42345]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cmds)
                                  op: Equal
                                  rhs: {($ VSub_Name "$old_postinstall_cmds")}
                                  spids: [42353]
                                )
                              ]
                              spids: [42353]
                            )
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:save_ifs)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                      spids: [42357]
                                    )
                                  ]
                                  spids: [42357]
                                )
                              terminator: <Op_Semi ";">
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(SQ <"~">)}
                                  spids: [42363]
                                )
                              ]
                              spids: [42363]
                            )
                            (ForEach
                              iter_name: cmd
                              iter_words: [{($ VSub_Name "$cmds")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                          spids: [42381]
                                        )
                                      ]
                                      spids: [42381]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike "cmd=") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      }
                                    )
                                    (C {($ VSub_Name "$show")} {(DQ ($ VSub_Name "$cmd"))})
                                    (AndOr
                                      children: [
                                        (C {($ VSub_Name "$run")} {(eval)} {(DQ ($ VSub_Name "$cmd"))})
                                        (C {(exit)} {($ VSub_QMark "$?")})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [42378 42417]
                                )
                              spids: [42374 42376]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                  spids: [42420]
                                )
                              ]
                              spids: [42420]
                            )
                          ]
                          spids: [42225 42426]
                        )
                      spids: [42221 42223]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$future_libdirs"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {
                                  (DQ ($ VSub_Name "$modename") (": warning: remember to run ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\`">
                                    ) ($ VSub_Name "$progname") (" --finish") ($ VSub_Name "$future_libdirs") ("'")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [42456]
                                )
                              ]
                            )
                          ]
                          spids: [-1 42441]
                        )
                      ]
                      spids: [-1 42460]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$current_libdirs"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$run"))})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:current_libdirs)
                                      op: Equal
                                      rhs: {(DQ (" -n") ($ VSub_Name "$current_libdirs"))}
                                      spids: [42492]
                                    )
                                  ]
                                  spids: [42492]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:exec_cmd)
                                  op: Equal
                                  rhs: 
                                    {
                                      (SQ 
                                        <
"$SHELL $progpath $preserve_args --finish$current_libdirs"
                                        >
                                      )
                                    }
                                  spids: [42499]
                                )
                              ]
                              spids: [42499]
                            )
                          ]
                          spids: [-1 42475]
                        )
                      ]
                      else_action: [(C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})]
                      spids: [42505 42513]
                    )
                  ]
                  spids: [38739 38740 42516 -1]
                )
                (case_arm
                  pat_list: [{(finish)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": finish"))}
                          spids: [42528]
                        )
                      ]
                      spids: [42528]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libdirs)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [42535]
                        )
                      ]
                      spids: [42535]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:admincmds)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [42541]
                        )
                      ]
                      spids: [42541]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ ($ VSub_Name "$finish_cmds") ($ VSub_Name "$finish_eval"))
                                      }
                                    )
                                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$libdirs"))})
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (ForEach
                              iter_name: dir
                              do_arg_iter: True
                              body: 
                                (DoGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:libdirs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$libdirs") (" ") ($ VSub_Name "$dir"))
                                            }
                                          spids: [42578]
                                        )
                                      ]
                                      spids: [42578]
                                    )
                                  ]
                                  spids: [42575 42586]
                                )
                              spids: [-1 -1]
                            )
                            (ForEach
                              iter_name: libdir
                              iter_words: [{($ VSub_Name "$libdirs")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$finish_cmds"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$finish_cmds")}
                                                  spids: [42620]
                                                )
                                              ]
                                              spids: [42620]
                                            )
                                            (Sentence
                                              child: 
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:save_ifs)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                      spids: [42624]
                                                    )
                                                  ]
                                                  spids: [42624]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(SQ <"~">)}
                                                  spids: [42630]
                                                )
                                              ]
                                              spids: [42630]
                                            )
                                            (ForEach
                                              iter_name: cmd
                                              iter_words: [{($ VSub_Name "$cmds")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                          spids: [42648]
                                                        )
                                                      ]
                                                      spids: [42648]
                                                    )
                                                    (C {(eval)} 
                                                      {(Lit_VarLike "cmd=") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\\"">
                                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                      }
                                                    )
                                                    (C {($ VSub_Name "$show")} 
                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {($ VSub_Name "$run")} {(eval)} 
                                                          {(DQ ($ VSub_Name "$cmd"))}
                                                        )
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:admincmds)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$admincmds") 
                                                                    ("\n") ("       ") ($ VSub_Name "$cmd")
                                                                  )
                                                                }
                                                              spids: [42679]
                                                            )
                                                          ]
                                                          spids: [42679]
                                                        )
                                                      ]
                                                      op_id: Op_DPipe
                                                    )
                                                  ]
                                                  spids: [42645 42688]
                                                )
                                              spids: [42641 42643]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                  spids: [42691]
                                                )
                                              ]
                                              spids: [42691]
                                            )
                                          ]
                                          spids: [-1 42613]
                                        )
                                      ]
                                      spids: [-1 42697]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$finish_eval"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike "cmds=") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) ($ VSub_Name "$finish_eval") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {($ VSub_Name "$run")} {(eval)} 
                                                  {(DQ ($ VSub_Name "$cmds"))}
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:admincmds)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$admincmds") ("\n") 
                                                            ("       ") ($ VSub_Name "$cmds")
                                                          )
                                                        }
                                                      spids: [42736]
                                                    )
                                                  ]
                                                  spids: [42736]
                                                )
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 42711]
                                        )
                                      ]
                                      spids: [-1 42745]
                                    )
                                  ]
                                  spids: [42599 42748]
                                )
                              spids: [42595 42597]
                            )
                          ]
                          spids: [-1 42567]
                        )
                      ]
                      spids: [-1 42751]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$show"))} {(Lit_Other "=")} {(Lit_Other ":")})
                        (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                      ]
                      op_id: Op_DAmp
                    )
                    (Pipeline
                      children: [
                        (C {($ VSub_Name "$echo")} 
                          {
                            (DQ 
                              (
X----------------------------------------------------------------------
                              )
                            )
                          }
                        )
                        (C {($ VSub_Name "$Xsed")})
                      ]
                      negated: False
                    )
                    (C {($ VSub_Name "$echo")} {(DQ ("Libraries have been installed in:"))})
                    (ForEach
                      iter_name: libdir
                      iter_words: [{($ VSub_Name "$libdirs")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [(C {($ VSub_Name "$echo")} {(DQ ("   ") ($ VSub_Name "$libdir"))})]
                          spids: [42804 42815]
                        )
                      spids: [42800 42802]
                    )
                    (C {($ VSub_Name "$echo")})
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("If you ever happen to want to link against installed libraries"))}
                    )
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("in a given directory, LIBDIR, you must either use libtool, and"))}
                    )
                    (C {($ VSub_Name "$echo")} 
                      {
                        (DQ ("specify the full pathname of the library, or use the ") 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-LLIBDIR'")
                        )
                      }
                    )
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("flag during linking and do at least one of the following:"))}
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath_var"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ("   - add LIBDIR to the ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\`">
                                  ) ($ VSub_Name "$shlibpath_var") ("' environment variable")
                                )
                              }
                            )
                            (C {($ VSub_Name "$echo")} {(DQ ("     during execution"))})
                          ]
                          spids: [-1 42862]
                        )
                      ]
                      spids: [-1 42882]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$runpath_var"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ("   - add LIBDIR to the ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\`">
                                  ) ($ VSub_Name "$runpath_var") ("' environment variable")
                                )
                              }
                            )
                            (C {($ VSub_Name "$echo")} {(DQ ("     during linking"))})
                          ]
                          spids: [-1 42896]
                        )
                      ]
                      spids: [-1 42916]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$hardcode_libdir_flag_spec"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:libdir)
                                  op: Equal
                                  rhs: {(LIBDIR)}
                                  spids: [42933]
                                )
                              ]
                              spids: [42933]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike "flag=") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                ) ($ VSub_Name "$hardcode_libdir_flag_spec") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                              }
                            )
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ("   - use the ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\`">
                                  ) ($ VSub_Name "$flag") ("' linker flag")
                                )
                              }
                            )
                          ]
                          spids: [-1 42930]
                        )
                      ]
                      spids: [-1 42956]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$admincmds"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ("   - have your system administrator run these commands:") 
                                  ($ VSub_Name "$admincmds")
                                )
                              }
                            )
                          ]
                          spids: [-1 42970]
                        )
                      ]
                      spids: [-1 42981]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-f)} {(/etc/ld.so.conf)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {($ VSub_Name "$echo")} 
                              {
                                (DQ ("   - have your system administrator add LIBDIR to ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\`">
                                  ) ("/etc/ld.so.conf'")
                                )
                              }
                            )
                          ]
                          spids: [-1 42993]
                        )
                      ]
                      spids: [-1 43005]
                    )
                    (C {($ VSub_Name "$echo")})
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("See any operating system documentation about shared libraries for"))}
                    )
                    (C {($ VSub_Name "$echo")} 
                      {(DQ ("more information, such as the ld(1) and ld.so(8) manual pages."))}
                    )
                    (Pipeline
                      children: [
                        (C {($ VSub_Name "$echo")} 
                          {
                            (DQ 
                              (
X----------------------------------------------------------------------
                              )
                            )
                          }
                        )
                        (C {($ VSub_Name "$Xsed")})
                      ]
                      negated: False
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                  ]
                  spids: [42524 42525 43041 -1]
                )
                (case_arm
                  pat_list: [{(execute)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": execute"))}
                          spids: [43053]
                        )
                      ]
                      spids: [43053]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cmd)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [43065]
                        )
                      ]
                      spids: [43065]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$cmd"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {(DQ ($ VSub_Name "$modename") (": you must specify a COMMAND"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [43092]
                                )
                              ]
                            )
                            (C {($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))})
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 43082]
                        )
                      ]
                      spids: [-1 43108]
                    )
                    (ForEach
                      iter_name: file
                      iter_words: [{($ VSub_Name "$execute_dlfiles")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(KW_Bang "!")} {(-f)} {(DQ ($ VSub_Name "$file"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ($ VSub_Name "$file") ("' is not a file")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [43154]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [43164]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                  ]
                                  spids: [-1 43141]
                                )
                              ]
                              spids: [-1 43173]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dir)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [43177]
                                )
                              ]
                              spids: [43177]
                            )
                            (Case
                              to_match: {($ VSub_Name "$file")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.la)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$file")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [43221]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [43224]
                                                    )
                                                  ]
                                                  spids: [43198 43219]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(C {(Lit_Other ":")})]
                                          spids: [-1 43228]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$lib") ("' is not a valid libtool archive")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [43246]
                                            )
                                          ]
                                        )
                                        (SimpleCommand
                                          words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [43256]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [43233 43265]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dlname)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [43273]
                                        )
                                      ]
                                      spids: [43273]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:library_names)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [43276]
                                        )
                                      ]
                                      spids: [43276]
                                    )
                                    (Case
                                      to_match: {($ VSub_Name "$file")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (/) (Lit_Other "*")}
                                            {(Lit_Other "*") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\\">
                                              ) (Lit_Other "*")
                                            }
                                          ]
                                          action: [(C {(.)} {($ VSub_Name "$file")})]
                                          spids: [43291 43300 43306 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [(C {(.)} {(./) ($ VSub_Name "$file")})]
                                          spids: [43309 43310 43317 -1]
                                        )
                                      ]
                                      spids: [43284 43288 43320]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$dlname"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$library_names"))})
                                                (C {($ VSub_Name "$echo")} 
                                                  {
                                                    (DQ ($ VSub_Name "$modename") (": warning: ") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\`">
                                                      ) ($ VSub_Name "$file") ("' was not linked with ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                                      ("-export-dynamic'")
                                                    )
                                                  }
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [-1 43339]
                                        )
                                      ]
                                      spids: [-1 43372]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$file"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%/[^/]*$%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [43377 43394]
                                              )
                                            }
                                          spids: [43376]
                                        )
                                      ]
                                      spids: [43376]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$dir"))} {(Lit_Other "=")} 
                                          {(DQ (X) ($ VSub_Name "$file"))}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:dir)
                                              op: Equal
                                              rhs: {(.)}
                                              spids: [43413]
                                            )
                                          ]
                                          spids: [43413]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(-f)} 
                                                  {
                                                    (DQ ($ VSub_Name "$dir") (/) 
                                                      ($ VSub_Name "$objdir") (/) ($ VSub_Name "$dlname")
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:dir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$dir") (/) 
                                                        ($ VSub_Name "$objdir")
                                                      )
                                                    }
                                                  spids: [43436]
                                                )
                                              ]
                                              spids: [43436]
                                            )
                                          ]
                                          spids: [-1 43433]
                                        )
                                      ]
                                      else_action: [
                                        (SimpleCommand
                                          words: [
                                            {($ VSub_Name "$echo")}
                                            {
                                              (DQ ($ VSub_Name "$modename") (": cannot find ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\`">
                                                ) ($ VSub_Name "$dlname") ("' in ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                                                ($ VSub_Name "$dir") ("' or ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$dir") (/) 
                                                ($ VSub_Name "$objdir") ("'")
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 1
                                              arg_word: {(2)}
                                              spids: [43465]
                                            )
                                          ]
                                        )
                                        (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                                      ]
                                      spids: [43444 43474]
                                    )
                                  ]
                                  spids: [43187 43189 43477 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.lo)}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {($ VSub_Name "$echo")} 
                                                            {(DQ (X) ($ VSub_Name "$file"))}
                                                          )
                                                          (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                            {(SQ <"s%/[^/]*$%%">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [43491 43508]
                                              )
                                            }
                                          spids: [43490]
                                        )
                                      ]
                                      spids: [43490]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$dir"))} {(Lit_Other "=")} 
                                          {(DQ (X) ($ VSub_Name "$file"))}
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:dir)
                                              op: Equal
                                              rhs: {(.)}
                                              spids: [43527]
                                            )
                                          ]
                                          spids: [43527]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  spids: [43481 43483 43531 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {($ VSub_Name "$echo")}
                                        {
                                          (DQ ($ VSub_Name "$modename") (": warning ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\`">
                                            ) ("-dlopen' is ignored for non-libtool libraries and objects")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 1
                                          arg_word: {(2)}
                                          spids: [43548]
                                        )
                                      ]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [43535 43536 43555 -1]
                                )
                              ]
                              spids: [43180 43184 43558]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:absdir)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (AndOr
                                                children: [
                                                  (C {(cd)} {(DQ ($ VSub_Name "$dir"))})
                                                  (C {(pwd)})
                                                ]
                                                op_id: Op_DAmp
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [43567 43577]
                                      )
                                    }
                                  spids: [43566]
                                )
                              ]
                              spids: [43566]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$absdir"))})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:dir)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$absdir"))}
                                      spids: [43590]
                                    )
                                  ]
                                  spids: [43590]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(eval)} 
                                          {
                                            (DQ ("test -z ") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\"">
                                              ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Name "$shlibpath_var") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\"">
                                              )
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {
                                        (DQ ($ VSub_Name "$shlibpath_var") ("=") 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\\"">
                                          ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (dir) 
                                          (EscapedLiteralPart
                                            token: <Lit_EscapedChar "\\\"">
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [-1 43614]
                                )
                              ]
                              else_action: [
                                (C {(eval)} 
                                  {
                                    (DQ ($ VSub_Name "$shlibpath_var") ("=") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\\"">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("dir:") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\$">
                                      ) ($ VSub_Name "$shlibpath_var") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                    )
                                  }
                                )
                              ]
                              spids: [43629 43646]
                            )
                          ]
                          spids: [43125 43649]
                        )
                      spids: [43121 43123]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libtool_execute_magic)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$magic"))}
                          spids: [43661]
                        )
                      ]
                      spids: [43661]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:args)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [43672]
                        )
                      ]
                      spids: [43672]
                    )
                    (ForEach
                      iter_name: file
                      do_arg_iter: True
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$file")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-) (Lit_Other "*")}]
                                  spids: [43690 43692 43694 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <4q>)} 
                                                          {($ VSub_Name "$file")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [43730]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [43733]
                                                    )
                                                  ]
                                                  spids: [43707 43728]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Case
                                              to_match: {($ VSub_Name "$file")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Other "*") (/) (Lit_Other "*")}
                                                    {(Lit_Other "*") 
                                                      (EscapedLiteralPart
                                                        token: <Lit_EscapedChar "\\\\">
                                                      ) (Lit_Other "*")
                                                    }
                                                  ]
                                                  action: [(C {(.)} {($ VSub_Name "$file")})]
                                                  spids: [43751 43760 43766 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*")}]
                                                  action: [(C {(.)} {(./) ($ VSub_Name "$file")})]
                                                  spids: [43769 43770 43777 -1]
                                                )
                                              ]
                                              spids: [43744 43748 43780]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:file)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$progdir") (/) 
                                                        ($ VSub_Name "$program")
                                                      )
                                                    }
                                                  spids: [43788]
                                                )
                                              ]
                                              spids: [43788]
                                            )
                                          ]
                                          spids: [-1 43737]
                                        )
                                      ]
                                      spids: [-1 43796]
                                    )
                                  ]
                                  spids: [43697 43698 43799 -1]
                                )
                              ]
                              spids: [43683 43687 43802]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:file)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$file"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(DQ ($ VSub_Name "$sed_quote_subst"))}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [43810 43827]
                                      )
                                    }
                                  spids: [43809]
                                )
                              ]
                              spids: [43809]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:args)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name "$args") (" ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\\"">
                                        ) ($ VSub_Name "$file") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                      )
                                    }
                                  spids: [43830]
                                )
                              ]
                              spids: [43830]
                            )
                          ]
                          spids: [43680 43840]
                        )
                      spids: [-1 -1]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$run"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath_var"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} {(DQ ("export ") ($ VSub_Name "$shlibpath_var"))})
                                  ]
                                  spids: [-1 43869]
                                )
                              ]
                              spids: [-1 43884]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} 
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name save_LC_ALL>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VTest_Plus
                                                    arg_word: {(set)}
                                                  )
                                                spids: [43897 43901]
                                              )
                                            )
                                          } {(Lit_Other "=")} {(set)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:LC_ALL)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$save_LC_ALL"))}
                                              spids: [43912]
                                            )
                                          ]
                                          spids: [43912]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (C {(export)} {(LC_ALL)})
                                  ]
                                  spids: [-1 43909]
                                )
                              ]
                              spids: [-1 43923]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} 
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name save_LANG>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VTest_Plus
                                                    arg_word: {(set)}
                                                  )
                                                spids: [43931 43935]
                                              )
                                            )
                                          } {(Lit_Other "=")} {(set)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:LANG)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name "$save_LANG"))}
                                              spids: [43946]
                                            )
                                          ]
                                          spids: [43946]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (C {(export)} {(LANG)})
                                  ]
                                  spids: [-1 43943]
                                )
                              ]
                              spids: [-1 43957]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:exec_cmd)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (cmd) 
                                        ($ VSub_Name "$args")
                                      )
                                    }
                                  spids: [43965]
                                )
                              ]
                              spids: [43965]
                            )
                          ]
                          spids: [-1 43855]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$shlibpath_var"))})
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(eval)} 
                                  {
                                    (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("echo ") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\\"">
                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("shlibpath_var=") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\$">
                                      ) ($ VSub_Name "$shlibpath_var") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                    )
                                  }
                                )
                                (C {($ VSub_Name "$echo")} 
                                  {(DQ ("export ") ($ VSub_Name "$shlibpath_var"))}
                                )
                              ]
                              spids: [-1 43991]
                            )
                          ]
                          spids: [-1 44016]
                        )
                        (C {($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$cmd") ($ VSub_Name "$args"))})
                        (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
                      ]
                      spids: [43973 44032]
                    )
                  ]
                  spids: [43049 43050 44035 -1]
                )
                (case_arm
                  pat_list: [{(clean)} {(uninstall)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:modename)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$modename") (": ") ($ VSub_Name "$mode"))}
                          spids: [44051]
                        )
                      ]
                      spids: [44051]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rm)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$nonopt"))}
                          spids: [44059]
                        )
                      ]
                      spids: [44059]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:files)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [44065]
                        )
                      ]
                      spids: [44065]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rmforce)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [44068]
                        )
                      ]
                      spids: [44068]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:exit_status)
                          op: Equal
                          rhs: {(0)}
                          spids: [44071]
                        )
                      ]
                      spids: [44071]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:libtool_install_magic)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$magic"))}
                          spids: [44084]
                        )
                      ]
                      spids: [44084]
                    )
                    (ForEach
                      iter_name: arg
                      do_arg_iter: True
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$arg")}
                              arms: [
                                (case_arm
                                  pat_list: [{(-f)}]
                                  action: [
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:rm)
                                              op: Equal
                                              rhs: 
                                                {(DQ ($ VSub_Name "$rm") (" ") ($ VSub_Name "$arg"))}
                                              spids: [44109]
                                            )
                                          ]
                                          spids: [44109]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rmforce)
                                          op: Equal
                                          rhs: {(yes)}
                                          spids: [44117]
                                        )
                                      ]
                                      spids: [44117]
                                    )
                                  ]
                                  spids: [44106 44107 44120 -1]
                                )
                                (case_arm
                                  pat_list: [{(-) (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rm)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$rm") (" ") ($ VSub_Name "$arg"))}
                                          spids: [44127]
                                        )
                                      ]
                                      spids: [44127]
                                    )
                                  ]
                                  spids: [44123 44125 44134 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:files)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$files") (" ") ($ VSub_Name "$arg"))}
                                          spids: [44140]
                                        )
                                      ]
                                      spids: [44140]
                                    )
                                  ]
                                  spids: [44137 44138 44147 -1]
                                )
                              ]
                              spids: [44099 44103 44150]
                            )
                          ]
                          spids: [44096 44153]
                        )
                      spids: [-1 -1]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$rm"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {($ VSub_Name "$echo")}
                                {(DQ ($ VSub_Name "$modename") (": you must specify an RM program"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [44178]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 1
                                  arg_word: {(2)}
                                  spids: [44188]
                                )
                              ]
                            )
                            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                          ]
                          spids: [-1 44168]
                        )
                      ]
                      spids: [-1 44197]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rmdirs)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [44201]
                        )
                      ]
                      spids: [44201]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:origobjdir)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$objdir"))}
                          spids: [44205]
                        )
                      ]
                      spids: [44205]
                    )
                    (ForEach
                      iter_name: file
                      iter_words: [{($ VSub_Name "$files")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dir)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$file"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} 
                                                    {(SQ <"s%/[^/]*$%%">)}
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [44224 44241]
                                      )
                                    }
                                  spids: [44223]
                                )
                              ]
                              spids: [44223]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ (X) ($ VSub_Name "$dir"))} {(Lit_Other "=")} 
                                          {(DQ (X) ($ VSub_Name "$file"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:dir)
                                          op: Equal
                                          rhs: {(.)}
                                          spids: [44264]
                                        )
                                      ]
                                      spids: [44264]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:objdir)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Name "$origobjdir"))}
                                          spids: [44268]
                                        )
                                      ]
                                      spids: [44268]
                                    )
                                  ]
                                  spids: [-1 44261]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:objdir)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$dir") (/) ($ VSub_Name "$origobjdir"))}
                                      spids: [44277]
                                    )
                                  ]
                                  spids: [44277]
                                )
                              ]
                              spids: [44274 44285]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {($ VSub_Name "$echo")} 
                                                    {(DQ (X) ($ VSub_Name "$file"))}
                                                  )
                                                  (C {($ VSub_Name "$Xsed")} {(-e)} {(SQ <"s%^.*/%%">)})
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_Backtick "`">
                                        spids: [44289 44306]
                                      )
                                    }
                                  spids: [44288]
                                )
                              ]
                              spids: [44288]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} {(Lit_Other "=")} {(uninstall)})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:objdir)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$dir"))}
                                      spids: [44321]
                                    )
                                  ]
                                  spids: [44321]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$mode"))} {(Lit_Other "=")} 
                                          {(clean)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {(DQ (" ") ($ VSub_Name "$rmdirs") (" "))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$objdir") (" ")) 
                                              (Lit_Other "*")
                                            }
                                          ]
                                          spids: [44359 44366 44368 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:rmdirs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$rmdirs") (" ") 
                                                        ($ VSub_Name "$objdir")
                                                      )
                                                    }
                                                  spids: [44374]
                                                )
                                              ]
                                              spids: [44374]
                                            )
                                          ]
                                          spids: [44371 44372 44381 -1]
                                        )
                                      ]
                                      spids: [44348 44356 44384]
                                    )
                                  ]
                                  spids: [-1 44345]
                                )
                              ]
                              spids: [-1 44387]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (AndOr
                                          children: [
                                            (Subshell
                                              child: (C {(test)} {(-L)} {(DQ ($ VSub_Name "$file"))})
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {(/dev/null)}
                                                  spids: [44407]
                                                )
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: 2
                                                  arg_word: {(1)}
                                                  spids: [44410]
                                                )
                                              ]
                                              spids: [44397 44405]
                                            )
                                            (AndOr
                                              children: [
                                                (Subshell
                                                  child: 
                                                    (C {(test)} {(-h)} {(DQ ($ VSub_Name "$file"))})
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [44427]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [44430]
                                                    )
                                                  ]
                                                  spids: [44417 44425]
                                                )
                                                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$file"))})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(Lit_Other ":")})]
                                  spids: [-1 44446]
                                )
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-d)} {(DQ ($ VSub_Name "$file"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:exit_status)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [44466]
                                        )
                                      ]
                                      spids: [44466]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [44452 44463]
                                )
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_Name "$rmforce"))} {(Lit_Other "=")} 
                                          {(yes)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                                  spids: [44473 44486]
                                )
                              ]
                              spids: [-1 44492]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:rmfiles)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$file"))}
                                  spids: [44496]
                                )
                              ]
                              spids: [44496]
                            )
                            (Case
                              to_match: {($ VSub_Name "$name")}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.la)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$file")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [44544]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [44547]
                                                    )
                                                  ]
                                                  spids: [44521 44542]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(.)} {($ VSub_Name "$dir") (/) ($ VSub_Name "$name")})
                                            (ForEach
                                              iter_name: n
                                              iter_words: [{($ VSub_Name "$library_names")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rmfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                ($ VSub_Name "$objdir") (/) ($ VSub_Name "$n")
                                                              )
                                                            }
                                                          spids: [44578]
                                                        )
                                                      ]
                                                      spids: [44578]
                                                    )
                                                  ]
                                                  spids: [44575 44588]
                                                )
                                              spids: [44571 44573]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$old_library"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:rmfiles)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                            ($ VSub_Name "$objdir") (/) ($ VSub_Name "$old_library")
                                                          )
                                                        }
                                                      spids: [44601]
                                                    )
                                                  ]
                                                  spids: [44601]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                            (Case
                                              to_match: {(DQ ($ VSub_Name "$mode"))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(clean)}]
                                                  action: [
                                                    (Case
                                                      to_match: 
                                                        {
                                                          (DQ ("  ") ($ VSub_Name "$library_names") 
                                                            (" ")
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Other "*") 
                                                              (DQ (" ") ($ VSub_Name "$dlname") (" ")) (Lit_Other "*")
                                                            }
                                                          ]
                                                          spids: [44640 44647 44649 -1]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Other "*")}]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:rmfiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$rmfiles") 
                                                                        (" ") ($ VSub_Name "$objdir") (/) ($ VSub_Name "$dlname")
                                                                      )
                                                                    }
                                                                  spids: [44655]
                                                                )
                                                              ]
                                                              spids: [44655]
                                                            )
                                                          ]
                                                          spids: [44652 44653 44664 -1]
                                                        )
                                                      ]
                                                      spids: [44625 44633 44667]
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$libdir"))})
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:rmfiles)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                    ($ VSub_Name "$objdir") (/) ($ VSub_Name "$name") (" ") ($ VSub_Name "$objdir") (/) (${ VSub_Name name) (i)
                                                                  )
                                                                }
                                                              spids: [44680]
                                                            )
                                                          ]
                                                          spids: [44680]
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  spids: [44621 44622 44697 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{(uninstall)}]
                                                  action: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_Name "$library_names")
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:cmds)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_Name 
"$postuninstall_cmds"
                                                                      )
                                                                    }
                                                                  spids: [44722]
                                                                )
                                                              ]
                                                              spids: [44722]
                                                            )
                                                            (Sentence
                                                              child: 
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:save_ifs)
                                                                      op: Equal
                                                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                                      spids: [44726]
                                                                    )
                                                                  ]
                                                                  spids: [44726]
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:IFS)
                                                                  op: Equal
                                                                  rhs: {(SQ <"~">)}
                                                                  spids: [44732]
                                                                )
                                                              ]
                                                              spids: [44732]
                                                            )
                                                            (ForEach
                                                              iter_name: cmd
                                                              iter_words: [{($ VSub_Name "$cmds")}]
                                                              do_arg_iter: False
                                                              body: 
                                                                (DoGroup
                                                                  children: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:IFS)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$save_ifs"
                                                                                )
                                                                              )
                                                                            }
                                                                          spids: [44750]
                                                                        )
                                                                      ]
                                                                      spids: [44750]
                                                                    )
                                                                    (C {(eval)} 
                                                                      {(Lit_VarLike "cmd=") 
                                                                        (EscapedLiteralPart
                                                                          token: 
                                                                            <Lit_EscapedChar "\\\"">
                                                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$show")} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (AndOr
                                                                                  children: [
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_QMark "$?"
                                                                                          )
                                                                                        )
                                                                                      } {(-ne)} {(0)}
                                                                                    )
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$rmforce"
                                                                                          )
                                                                                        )
                                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                                    )
                                                                                  ]
                                                                                  op_id: Op_DAmp
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
exit_status
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(1)}
                                                                                  spids: [44809]
                                                                                )
                                                                              ]
                                                                              spids: [44809]
                                                                            )
                                                                          ]
                                                                          spids: [-1 44806]
                                                                        )
                                                                      ]
                                                                      spids: [-1 44813]
                                                                    )
                                                                  ]
                                                                  spids: [44747 44816]
                                                                )
                                                              spids: [44743 44745]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:IFS)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                                  spids: [44819]
                                                                )
                                                              ]
                                                              spids: [44819]
                                                            )
                                                          ]
                                                          spids: [-1 44715]
                                                        )
                                                      ]
                                                      spids: [-1 44825]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {(DQ ($ VSub_Name "$old_library"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:cmds)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_Name 
"$old_postuninstall_cmds"
                                                                      )
                                                                    }
                                                                  spids: [44847]
                                                                )
                                                              ]
                                                              spids: [44847]
                                                            )
                                                            (Sentence
                                                              child: 
                                                                (Assignment
                                                                  keyword: Assign_None
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: (LhsName name:save_ifs)
                                                                      op: Equal
                                                                      rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                                      spids: [44851]
                                                                    )
                                                                  ]
                                                                  spids: [44851]
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:IFS)
                                                                  op: Equal
                                                                  rhs: {(SQ <"~">)}
                                                                  spids: [44857]
                                                                )
                                                              ]
                                                              spids: [44857]
                                                            )
                                                            (ForEach
                                                              iter_name: cmd
                                                              iter_words: [{($ VSub_Name "$cmds")}]
                                                              do_arg_iter: False
                                                              body: 
                                                                (DoGroup
                                                                  children: [
                                                                    (Assignment
                                                                      keyword: Assign_None
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: (LhsName name:IFS)
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
"$save_ifs"
                                                                                )
                                                                              )
                                                                            }
                                                                          spids: [44875]
                                                                        )
                                                                      ]
                                                                      spids: [44875]
                                                                    )
                                                                    (C {(eval)} 
                                                                      {(Lit_VarLike "cmd=") 
                                                                        (EscapedLiteralPart
                                                                          token: 
                                                                            <Lit_EscapedChar "\\\"">
                                                                        ) ($ VSub_Name "$cmd") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                                      }
                                                                    )
                                                                    (C {($ VSub_Name "$show")} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (C {($ VSub_Name "$run")} {(eval)} 
                                                                      {(DQ ($ VSub_Name "$cmd"))}
                                                                    )
                                                                    (If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (Sentence
                                                                              child: 
                                                                                (AndOr
                                                                                  children: [
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_QMark "$?"
                                                                                          )
                                                                                        )
                                                                                      } {(-ne)} {(0)}
                                                                                    )
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_Name "$rmforce"
                                                                                          )
                                                                                        )
                                                                                      } {(KW_Bang "!") (Lit_Other "=")} {(yes)}
                                                                                    )
                                                                                  ]
                                                                                  op_id: Op_DAmp
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ";">
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (Assignment
                                                                              keyword: Assign_None
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (LhsName
                                                                                      name: 
exit_status
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(1)}
                                                                                  spids: [44934]
                                                                                )
                                                                              ]
                                                                              spids: [44934]
                                                                            )
                                                                          ]
                                                                          spids: [-1 44931]
                                                                        )
                                                                      ]
                                                                      spids: [-1 44938]
                                                                    )
                                                                  ]
                                                                  spids: [44872 44941]
                                                                )
                                                              spids: [44868 44870]
                                                            )
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:IFS)
                                                                  op: Equal
                                                                  rhs: {(DQ ($ VSub_Name "$save_ifs"))}
                                                                  spids: [44944]
                                                                )
                                                              ]
                                                              spids: [44944]
                                                            )
                                                          ]
                                                          spids: [-1 44840]
                                                        )
                                                      ]
                                                      spids: [-1 44950]
                                                    )
                                                  ]
                                                  spids: [44700 44701 44957 -1]
                                                )
                                              ]
                                              spids: [44612 44618 44960]
                                            )
                                          ]
                                          spids: [-1 44551]
                                        )
                                      ]
                                      spids: [-1 44963]
                                    )
                                  ]
                                  spids: [44510 44512 44966 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*") (.lo)}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Subshell
                                                  child: 
                                                    (Pipeline
                                                      children: [
                                                        (C {(${ VSub_Name SED)} {(-e)} {(SQ <2q>)} 
                                                          {($ VSub_Name "$file")}
                                                        )
                                                        (C {(grep)} 
                                                          {
                                                            (DQ ("^# Generated by .*") 
                                                              ($ VSub_Name "$PACKAGE")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [45004]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [45007]
                                                    )
                                                  ]
                                                  spids: [44981 45002]
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(.)} {($ VSub_Name "$dir") (/) ($ VSub_Name "$name")})
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$pic_object"))}
                                                            )
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$pic_object"))} {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rmfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$pic_object")
                                                              )
                                                            }
                                                          spids: [45060]
                                                        )
                                                      ]
                                                      spids: [45060]
                                                    )
                                                  ]
                                                  spids: [-1 45057]
                                                )
                                              ]
                                              spids: [-1 45070]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (AndOr
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_Name "$non_pic_object"))}
                                                            )
                                                            (C {(test)} 
                                                              {(DQ ($ VSub_Name "$non_pic_object"))} {(KW_Bang "!") (Lit_Other "=")} {(none)}
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rmfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                ($ VSub_Name "$dir") (/) ($ VSub_Name "$non_pic_object")
                                                              )
                                                            }
                                                          spids: [45107]
                                                        )
                                                      ]
                                                      spids: [45107]
                                                    )
                                                  ]
                                                  spids: [-1 45104]
                                                )
                                              ]
                                              spids: [-1 45117]
                                            )
                                          ]
                                          spids: [-1 45011]
                                        )
                                      ]
                                      spids: [-1 45120]
                                    )
                                  ]
                                  spids: [44970 44972 45123 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Name "$mode"))} 
                                                  {(Lit_Other "=")} {(clean)}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:noexename)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$name")}
                                                  spids: [45148]
                                                )
                                              ]
                                              spids: [45148]
                                            )
                                            (Case
                                              to_match: {($ VSub_Name "$file")}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(Lit_Other "*") (.exe)}]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:file)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {($ VSub_Name "$file")}
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(SQ <"s,.exe$,,">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [45165 45177]
                                                              )
                                                            }
                                                          spids: [45164]
                                                        )
                                                      ]
                                                      spids: [45164]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:noexename)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (Pipeline
                                                                        children: [
                                                                          (C {($ VSub_Name "$echo")} 
                                                                            {($ VSub_Name "$name")}
                                                                          )
                                                                          (C {(${ VSub_Name SED)} 
                                                                            {(SQ <"s,.exe$,,">)}
                                                                          )
                                                                        ]
                                                                        negated: False
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_Backtick "`">
                                                                spids: [45181 45193]
                                                              )
                                                            }
                                                          spids: [45180]
                                                        )
                                                      ]
                                                      spids: [45180]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rmfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                ($ VSub_Name "$file")
                                                              )
                                                            }
                                                          spids: [45204]
                                                        )
                                                      ]
                                                      spids: [45204]
                                                    )
                                                  ]
                                                  spids: [45159 45161 45212 -1]
                                                )
                                              ]
                                              spids: [45152 45156 45215]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (Subshell
                                                          child: 
                                                            (Pipeline
                                                              children: [
                                                                (C {(${ VSub_Name SED)} {(-e)} 
                                                                  {(SQ <4q>)} {($ VSub_Name "$file")}
                                                                )
                                                                (C {(grep)} 
                                                                  {
                                                                    (DQ ("^# Generated by .*") 
                                                                      ($ VSub_Name "$PACKAGE")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                              negated: False
                                                            )
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: {(/dev/null)}
                                                              spids: [45247]
                                                            )
                                                            (Redir
                                                              op_id: Redir_GreatAnd
                                                              fd: 2
                                                              arg_word: {(1)}
                                                              spids: [45250]
                                                            )
                                                          ]
                                                          spids: [45224 45245]
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:relink_command)
                                                          op: Equal
                                                          rhs: {(SQ )}
                                                          spids: [45257]
                                                        )
                                                      ]
                                                      spids: [45257]
                                                    )
                                                    (C {(.)} 
                                                      {($ VSub_Name "$dir") (/) 
                                                        ($ VSub_Name "$noexename")
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:rmfiles)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_Name "$rmfiles") (" ") 
                                                                ($ VSub_Name "$objdir") (/) ($ VSub_Name "$name") (" ") ($ VSub_Name "$objdir") (/) (${ VSub_Name name) (S.) (${ VSub_Name objext)
                                                              )
                                                            }
                                                          spids: [45276]
                                                        )
                                                      ]
                                                      spids: [45276]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (AndOr
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$fast_install"
                                                                          )
                                                                        )
                                                                      } {(Lit_Other "=")} {(yes)}
                                                                    )
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name 
"$relink_command"
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  op_id: Op_DAmp
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:rmfiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$rmfiles") 
                                                                        (" ") ($ VSub_Name "$objdir") (/lt-) ($ VSub_Name "$name")
                                                                      )
                                                                    }
                                                                  spids: [45322]
                                                                )
                                                              ]
                                                              spids: [45322]
                                                            )
                                                          ]
                                                          spids: [-1 45319]
                                                        )
                                                      ]
                                                      spids: [-1 45332]
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(test)} 
                                                                  {
                                                                    (DQ (X) ($ VSub_Name "$noexename"))
                                                                  } {(KW_Bang "!") (Lit_Other "=")} {(DQ (X) ($ VSub_Name "$name"))}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (LhsName name:rmfiles)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_Name "$rmfiles") 
                                                                        (" ") ($ VSub_Name "$objdir") (/lt-) (${ VSub_Name noexename) (.c)
                                                                      )
                                                                    }
                                                                  spids: [45357]
                                                                )
                                                              ]
                                                              spids: [45357]
                                                            )
                                                          ]
                                                          spids: [-1 45354]
                                                        )
                                                      ]
                                                      spids: [-1 45370]
                                                    )
                                                  ]
                                                  spids: [-1 45254]
                                                )
                                              ]
                                              spids: [-1 45373]
                                            )
                                          ]
                                          spids: [-1 45145]
                                        )
                                      ]
                                      spids: [-1 45376]
                                    )
                                  ]
                                  spids: [45127 45128 45379 -1]
                                )
                              ]
                              spids: [44503 44507 45382]
                            )
                            (C {($ VSub_Name "$show")} 
                              {(DQ ($ VSub_Name "$rm") (" ") ($ VSub_Name "$rmfiles"))}
                            )
                            (AndOr
                              children: [
                                (C {($ VSub_Name "$run")} {($ VSub_Name "$rm")} 
                                  {($ VSub_Name "$rmfiles")}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:exit_status)
                                      op: Equal
                                      rhs: {(1)}
                                      spids: [45402]
                                    )
                                  ]
                                  spids: [45402]
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [44220 45406]
                        )
                      spids: [44216 44218]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:objdir)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$origobjdir"))}
                          spids: [45409]
                        )
                      ]
                      spids: [45409]
                    )
                    (ForEach
                      iter_name: dir
                      iter_words: [{($ VSub_Name "$rmdirs")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (C {(test)} {(-d)} {(DQ ($ VSub_Name "$dir"))})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {($ VSub_Name "$show")} {(DQ ("rmdir ") ($ VSub_Name "$dir"))})
                                    (SimpleCommand
                                      words: [{($ VSub_Name "$run")} {(rmdir)} {($ VSub_Name "$dir")}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [45460]
                                        )
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 2
                                          arg_word: {(1)}
                                          spids: [45463]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 45443]
                                )
                              ]
                              spids: [-1 45467]
                            )
                          ]
                          spids: [45429 45470]
                        )
                      spids: [45425 45427]
                    )
                    (C {(exit)} {($ VSub_Name "$exit_status")})
                  ]
                  spids: [44043 44048 45479 -1]
                )
                (case_arm
                  pat_list: [{(DQ )}]
                  action: [
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {(DQ ($ VSub_Name "$modename") (": you must specify a MODE"))}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45495])]
                    )
                    (SimpleCommand
                      words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$generic_help"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45505])]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                  ]
                  spids: [-1 45485 45514 -1]
                )
              ]
              spids: [4076 4080 45517]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$exec_cmd"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {($ VSub_Name "$echo")}
                        {
                          (DQ ($ VSub_Name "$modename") (": invalid operation mode ") 
                            (EscapedLiteralPart
                              token: <Lit_EscapedChar "\\`">
                            ) ($ VSub_Name "$mode") ("'")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45545])]
                    )
                    (SimpleCommand
                      words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$generic_help"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45555])]
                    )
                    (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
                  ]
                  spids: [-1 45532]
                )
              ]
              spids: [-1 45564]
            )
          ]
          spids: [-1 3702]
        )
      ]
      spids: [-1 45566]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$exec_cmd"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(eval)} {(exec)} {($ VSub_Name "$exec_cmd")})
            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
          ]
          spids: [-1 45583]
        )
      ]
      spids: [-1 45597]
    )
    (Case
      to_match: {($ VSub_Name "$mode")}
      arms: [
        (case_arm
          pat_list: [{(DQ )}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") (" [OPTION]... [MODE-ARG]...\n") ("\n") 
                  ("Provide generalized library-building support services.\n") ("\n") ("    --config          show all configuration variables\n") 
                  ("    --debug           enable verbose shell tracing\n") ("-n, --dry-run         display commands without modifying any files\n") 
                  ("    --features        display basic configuration information and exit\n") ("    --finish          same as ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                  ("--mode=finish'\n") ("    --help            display this help message and exit\n") 
                  (
"    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]\n"
                  ) ("    --quiet           same as ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("--silent'\n") 
                  ("    --silent          don't print informational messages\n") ("    --tag=TAG         use configuration variables from tag TAG\n") 
                  ("    --version         print version information\n") ("\n") ("MODE must be one of the following:\n") ("\n") 
                  ("      clean           remove files from the build directory\n") ("      compile         compile a source file into a libtool object\n") 
                  ("      execute         automatically set library path, then run a program\n") ("      finish          complete the installation of libtool libraries\n") 
                  ("      install         install libraries or executables\n") ("      link            create a library or an executable\n") 
                  ("      uninstall       remove libraries from an installed directory\n") ("\n") ("MODE-ARGS vary depending on the MODE.  Try ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$modename") (" --help --mode=MODE' for\n") ("a more detailed description of MODE.\n") 
                  ("\n") ("Report bugs to <bug-libtool@gnu.org>.")
                )
              }
            )
            (C {(exit)} {($ VSub_Name "$EXIT_SUCCESS")})
          ]
          spids: [-1 45611 45664 -1]
        )
        (case_arm
          pat_list: [{(clean)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=clean RM [RM-OPTION]... FILE...\n") ("\n") ("Remove files from the build directory.\n") ("\n") 
                  (
"RM is the name of the program to use to delete files associated with each FILE\n"
                  ) ("(typically ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                  ("/bin/rm').  RM-OPTIONS are options (such as ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-f') to be passed\n") ("to RM.\n") ("\n") 
                  ("If FILE is a libtool library, object or program, all the files associated\n") ("with it are deleted. Otherwise, only FILE itself is deleted using RM.")
                )
              }
            )
          ]
          spids: [45667 45668 45694 -1]
        )
        (case_arm
          pat_list: [{(compile)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE\n") ("\n") ("Compile a source file into a libtool library object.\n") ("\n") 
                  ("This mode accepts the following additional options:\n") ("\n") ("  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE\n") 
                  ("  -prefer-pic       try to building PIC objects only\n") ("  -prefer-non-pic   try to building non-PIC objects only\n") ("  -static           always build a ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".o' file suitable for static linking\n") ("\n") 
                  ("COMPILE-COMMAND is a command to be used in creating a ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("standard' object file\n") 
                  ("from the given SOURCEFILE.\n") ("\n") ("The output file name is determined by removing the directory component from\n") 
                  ("SOURCEFILE, then substituting the C source code suffix ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".c' with the\n") ("library object suffix, ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".lo'.")
                )
              }
            )
          ]
          spids: [45697 45698 45735 -1]
        )
        (case_arm
          pat_list: [{(execute)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=execute COMMAND [ARGS]...\n") ("\n") ("Automatically set library path, then run a program.\n") ("\n") 
                  ("This mode accepts the following additional options:\n") ("\n") ("  -dlopen FILE      add the directory containing FILE to the library path\n") ("\n") 
                  ("This mode sets the library path environment variable according to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-dlopen'\n") ("flags.\n") ("\n") 
                  (
"If any of the ARGS are libtool executable wrappers, then they are translated\n"
                  ) ("into their corresponding uninstalled binary, and any of their required library\n") 
                  ("directories are added to the library path.\n") ("\n") ("Then, COMMAND is executed, with ARGS as arguments.")
                )
              }
            )
          ]
          spids: [45738 45739 45769 -1]
        )
        (case_arm
          pat_list: [{(finish)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") (" [OPTION]... --mode=finish [LIBDIR]...\n") 
                  ("\n") ("Complete the installation of libtool libraries.\n") ("\n") 
                  ("Each LIBDIR is a directory that contains libtool libraries.\n") ("\n") ("The commands that this mode executes may require superuser privileges.  Use\n") ("the ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("--dry-run' option if you just want to see what would be executed.")
                )
              }
            )
          ]
          spids: [45772 45773 45795 -1]
        )
        (case_arm
          pat_list: [{(install)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=install INSTALL-COMMAND...\n") ("\n") ("Install executables or libraries.\n") ("\n") 
                  ("INSTALL-COMMAND is the installation command.  The first component should be\n") ("either the ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("install' or ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("cp' program.\n") ("\n") 
                  (
"The rest of the components are interpreted as arguments to that command (only\n"
                  ) ("BSD-compatible install options are recognized).")
                )
              }
            )
          ]
          spids: [45798 45799 45824 -1]
        )
        (case_arm
          pat_list: [{(link)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=link LINK-COMMAND...\n") ("\n") ("Link object files or libraries together to form another library, or to\n") 
                  ("create an executable program.\n") ("\n") ("LINK-COMMAND is a command using the C compiler that you would use to create\n") 
                  ("a program from several object files.\n") ("\n") ("The following components of LINK-COMMAND are treated specially:\n") ("\n") 
                  ("  -all-static       do not do any dynamic linking at all\n") ("  -avoid-version    do not add a version suffix if possible\n") ("  -dlopen FILE      ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-dlpreopen' FILE if it cannot be dlopened at runtime\n") 
                  (
"  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols\n"
                  ) ("  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)\n") 
                  ("  -export-symbols SYMFILE\n") ("\t\t    try to export only the symbols listed in SYMFILE\n") ("  -export-symbols-regex REGEX\n") 
                  ("\t\t    try to export only the symbols matching REGEX\n") ("  -LLIBDIR          search LIBDIR for required installed libraries\n") 
                  ("  -lNAME            OUTPUT-FILE requires the installed library libNAME\n") ("  -module           build a library that can dlopened\n") 
                  ("  -no-fast-install  disable the fast-install mode\n") ("  -no-install       link a not-installable executable\n") 
                  (
"  -no-undefined     declare that a library does not refer to external symbols\n"
                  ) ("  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects\n") 
                  (
"  -objectlist FILE  Use a list of object files found in FILE to specify objects\n"
                  ) ("  -precious-files-regex REGEX\n") ("                    don't remove output files matching REGEX\n") 
                  ("  -release RELEASE  specify package release information\n") ("  -rpath LIBDIR     the created library will eventually be installed in LIBDIR\n") 
                  (
"  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries\n"
                  ) ("  -static           do not do any dynamic linking of libtool libraries\n") 
                  ("  -version-info CURRENT[:REVISION[:AGE]]\n") ("\t\t    specify library version info [each variable defaults to 0]\n") ("\n") 
                  ("All other options (arguments beginning with ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-') are ignored.\n") ("\n") 
                  ("Every other argument is treated as a filename.  Files ending in ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".la' are\n") 
                  (
"treated as uninstalled libtool libraries, other files are standard or library\n"
                  ) ("object files.\n") ("\n") ("If the OUTPUT-FILE ends in ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".la', then a libtool library is created,\n") ("only library objects (") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".lo' files) may be specified, and ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                  ("-rpath' is\n") ("required, except when creating a convenience library.\n") ("\n") ("If OUTPUT-FILE ends in ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".a' or ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                  (".lib', then a standard library is created\n") ("using ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("ar' and ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("ranlib', or on Windows using ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("lib'.\n") ("\n") 
                  ("If OUTPUT-FILE ends in ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (".lo' or ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) (.) (${ VSub_Name objext) ("', then a reloadable object file\n") 
                  ("is created, otherwise an executable program is created.")
                )
              }
            )
          ]
          spids: [45827 45828 45921 -1]
        )
        (case_arm
          pat_list: [{(uninstall)}]
          action: [
            (C {($ VSub_Name "$echo")} 
              {
                (DQ ("Usage: ") ($ VSub_Name "$modename") 
                  (" [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...\n") ("\n") ("Remove libraries from an installation directory.\n") ("\n") 
                  (
"RM is the name of the program to use to delete files associated with each FILE\n"
                  ) ("(typically ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) 
                  ("/bin/rm').  RM-OPTIONS are options (such as ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ("-f') to be passed\n") ("to RM.\n") ("\n") 
                  ("If FILE is a libtool library, all the files associated with it are deleted.\n") ("Otherwise, only FILE itself is deleted using RM.")
                )
              }
            )
          ]
          spids: [45924 45925 45951 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (SimpleCommand
              words: [
                {($ VSub_Name "$echo")}
                {
                  (DQ ($ VSub_Name "$modename") (": invalid operation mode ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$mode") ("'")
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45968])]
            )
            (SimpleCommand
              words: [{($ VSub_Name "$echo")} {(DQ ($ VSub_Name "$help"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:1 arg_word:{(2)} spids:[45978])]
            )
            (C {(exit)} {($ VSub_Name "$EXIT_FAILURE")})
          ]
          spids: [45954 45955 45987 -1]
        )
      ]
      spids: [45603 45607 45989]
    )
    (C {($ VSub_Name "$echo")})
    (C {($ VSub_Name "$echo")} 
      {
        (DQ ("Try ") (EscapedLiteralPart token:<Lit_EscapedChar "\\`">) ($ VSub_Name "$modename") 
          (" --help' for more information about other modes.")
        )
      }
    )
    (C {(exit)} {($ VSub_QMark "$?")})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:disable_libs) op:Equal rhs:{(shared)} spids:[46043])]
      spids: [46043]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:disable_libs) op:Equal rhs:{(static)} spids:[46053])]
      spids: [46053]
    )
  ]
)