(command.CommandList
  children: [
    (command.FuncDef
      name: meta2src
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(cat)} {(/dev/null)} {(DQ ($ VSub_At '$@'))})
                (C {(sed)} {(-n)} {(SQ <'/^R .*\\.[chyl]$/s,^..[0-9]* ,,p'>)})
                (C {(sort)} {(-u)})
              ]
              negated: F
            )
          ]
          spids: [309]
        )
      spids: [305 308]
    )
    (command.FuncDef
      name: meta2dirs
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(cat)} {(/dev/null)} {(DQ ($ VSub_At '$@'))})
                (C {(sed)} {(-n)} 
                  {(SQ <'/^R .*\\/.*\\.[a-z0-9][^\\/]*$/s,^..[0-9]* \\(.*\\)/[^/]*$,\\1,p'>)}
                )
                (C {(sort)} {(-u)})
              ]
              negated: F
            )
          ]
          spids: [346]
        )
      spids: [342 345]
    )
    (command.FuncDef
      name: add_list
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sep spids:[385])
                  op: Equal
                  rhs: {(SQ <' '>)}
                  spids: [385]
                )
              ]
              spids: [385]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:suffix spids:[391])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [391]
                )
              ]
              spids: [391]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(Lit_Other ':')})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ ('|'))}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:sep spids:[416])
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Number '$1'))}
                                      spids: [416]
                                    )
                                  ]
                                  spids: [416]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)})
                          ]
                          spids: [411 414 423 16777215]
                        )
                        (case_arm
                          pat_list: [{(-s)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:suffix spids:[429])
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Number '$2'))}
                                      spids: [429]
                                    )
                                  ]
                                  spids: [429]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [426 427 438 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [441 442 445 16777215]
                        )
                      ]
                      spids: [402 408 448]
                    )
                  ]
                  spids: [399 451]
                )
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:name spids:[454])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [454]
                )
              ]
              spids: [454]
            )
            (C {(shift)})
            (C {(eval)} 
              {(Lit_VarLike 'list=') 
                (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                  ($ VSub_DollarName '$name')
                )
              }
            )
            (command.ForEach
              iter_name: top
              iter_words: [{(DQ ($ VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: 
                        {
                          (DQ ($ VSub_DollarName '$sep') ($ VSub_DollarName '$list') 
                            ($ VSub_DollarName '$sep')
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '*') 
                              (DQ ($ VSub_DollarName '$sep') ($ VSub_DollarName '$top') 
                                ($ VSub_DollarName '$suffix') ($ VSub_DollarName '$sep')
                              ) (Lit_Other '*')
                            }
                          ]
                          action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [495 503 506 16777215]
                        )
                      ]
                      spids: [484 492 509]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:list spids:[512])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Name list>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VTest_ColonPlus
                                      arg_word: 
                                        {($ VSub_DollarName '$list') ($ VSub_DollarName '$sep')}
                                    )
                                  spids: [514 519]
                                ) ($ VSub_DollarName '$top') ($ VSub_DollarName '$suffix')
                              )
                            }
                          spids: [512]
                        )
                      ]
                      spids: [512]
                    )
                  ]
                  spids: [481 525]
                )
              spids: [475 16777215]
            )
            (C {(eval)} 
              {
                (DQ ($ VSub_DollarName '$name') ('=') 
                  (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$list') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
                )
              }
            )
          ]
          spids: [382]
        )
      spids: [378 381]
    )
    (command.FuncDef
      name: _excludes_f
      body: 
        (command.BraceGroup
          children: [(C {(egrep)} {(-v)} {(DQ ($ VSub_DollarName '$EXCLUDES'))})]
          spids: [545]
        )
      spids: [541 544]
    )
    (command.FuncDef
      name: meta2deps
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:DPDEPS spids:[566])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [566]
                )
              ]
              spids: [566]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:SRCTOPS spids:[569])
                  op: Equal
                  rhs: {($ VSub_DollarName '$SRCTOP')}
                  spids: [569]
                )
              ]
              spids: [569]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:OBJROOTS spids:[573])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [573]
                )
              ]
              spids: [573]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:EXCLUDES spids:[576])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [576]
                )
              ]
              spids: [576]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(Lit_Other ':')})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (Lit_Other '=') (Lit_Other '*')}]
                          action: [
                            (command.Sentence
                              child: (C {(eval)} {(export)} {(DQ ($ VSub_Number '$1'))})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)})
                          ]
                          spids: [596 599 611 16777215]
                        )
                        (case_arm
                          pat_list: [{(-a)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:MACHINE_ARCH spids:[617])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [617]
                                    )
                                  ]
                                  spids: [617]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [614 615 624 16777215]
                        )
                        (case_arm
                          pat_list: [{(-m)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:MACHINE spids:[630])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [630]
                                    )
                                  ]
                                  spids: [630]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [627 628 637 16777215]
                        )
                        (case_arm
                          pat_list: [{(-C)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:CURDIR spids:[643])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [643]
                                    )
                                  ]
                                  spids: [643]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [640 641 650 16777215]
                        )
                        (case_arm
                          pat_list: [{(-H)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:HOST_TARGET spids:[656])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [656]
                                    )
                                  ]
                                  spids: [656]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [653 654 663 16777215]
                        )
                        (case_arm
                          pat_list: [{(-S)}]
                          action: [
                            (command.Sentence
                              child: (C {(add_list)} {(SRCTOPS)} {($ VSub_Number '$2')})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [666 667 679 16777215]
                        )
                        (case_arm
                          pat_list: [{(-O)}]
                          action: [
                            (command.Sentence
                              child: (C {(add_list)} {(OBJROOTS)} {($ VSub_Number '$2')})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [682 683 695 16777215]
                        )
                        (case_arm
                          pat_list: [{(-X)}]
                          action: [
                            (command.Sentence
                              child: (C {(add_list)} {(EXCLUDES)} {(SQ <'|'>)} {($ VSub_Number '$2')})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [698 699 715 16777215]
                        )
                        (case_arm
                          pat_list: [{(-R)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:RELDIR spids:[721])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [721]
                                    )
                                  ]
                                  spids: [721]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [718 719 728 16777215]
                        )
                        (case_arm
                          pat_list: [{(-T)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:TARGET_SPEC spids:[734])
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [734]
                                    )
                                  ]
                                  spids: [734]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)} {(2)})
                          ]
                          spids: [731 732 741 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [744 745 748 16777215]
                        )
                      ]
                      spids: [587 593 751]
                    )
                  ]
                  spids: [584 754]
                )
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:_th spids:[758])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [758]
                )
                (assign_pair
                  lhs: (lhs_expr.LhsName name:_o spids:[760])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [760]
                )
              ]
              spids: [758]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$MACHINE'))}
              arms: [
                (case_arm
                  pat_list: [{(host)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:_ht spids:[775])
                          op: Equal
                          rhs: {($ VSub_DollarName '$HOST_TARGET')}
                          spids: [775]
                        )
                      ]
                      spids: [775]
                    )
                  ]
                  spids: [772 773 777 16777215]
                )
              ]
              spids: [763 769 780]
            )
            (command.ForEach
              iter_name: o
              iter_words: [{($ VSub_DollarName '$OBJROOTS')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: 
                        {(DQ ($ VSub_DollarName '$MACHINE') (',/') ($ VSub_DollarName '$o') (/))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(host) (Lit_Comma ',') (Lit_Other '*') ($ VSub_DollarName '$HOST_TARGET') 
                              (Lit_Other '*')
                            }
                          ]
                          spids: [809 814 816 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(Lit_Other '*') ($ VSub_DollarName '$MACHINE') (Lit_Other '*')}
                            {(Lit_Other '*') 
                              (word_part.BracedVarSub
                                token: <VSub_Name TARGET_SPEC>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VTest_ColonHyphen
                                    arg_word: {($ VSub_DollarName '$MACHINE')}
                                  )
                                spids: [824 828]
                              ) (Lit_Other '*')
                            }
                          ]
                          spids: [819 830 832 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.Sentence
                              child: (C {(add_list)} {(_o)} {($ VSub_DollarName '$o')})
                              terminator: <Op_Semi ';'>
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          spids: [835 836 846 16777215]
                        )
                      ]
                      spids: [797 806 849]
                    )
                    (command.ForEach
                      iter_name: x
                      iter_words: [
                        {($ VSub_DollarName '$_ht')}
                        {($ VSub_DollarName '$TARGET_SPEC')}
                        {($ VSub_DollarName '$MACHINE')}
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$o'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(DQ )}]
                                  action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                                  spids: [877 879 882 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*') (/) ($ VSub_DollarName '$x') (/)}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(add_list)} {(_o)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name o>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Percent
                                                  arg_word: {($ VSub_DollarName '$x') (Lit_Slash /)}
                                                )
                                              spids: [895 900]
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:o spids:[903])
                                          op: Equal
                                          rhs: (word.EmptyWord)
                                          spids: [903]
                                        )
                                      ]
                                      spids: [903]
                                    )
                                  ]
                                  spids: [885 889 904 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*') (/) ($ VSub_DollarName '$x')}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(add_list)} {(_o)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name o>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Percent
                                                  arg_word: {($ VSub_DollarName '$x')}
                                                )
                                              spids: [916 920]
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:o spids:[923])
                                          op: Equal
                                          rhs: (word.EmptyWord)
                                          spids: [923]
                                        )
                                      ]
                                      spids: [923]
                                    )
                                  ]
                                  spids: [907 910 924 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*') ($ VSub_DollarName '$x') (/)}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(add_list)} {(_o)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name o>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Percent
                                                  arg_word: {($ VSub_DollarName '$x') (Lit_Slash /)}
                                                )
                                              spids: [936 941]
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:o spids:[944])
                                          op: Equal
                                          rhs: (word.EmptyWord)
                                          spids: [944]
                                        )
                                      ]
                                      spids: [944]
                                    )
                                  ]
                                  spids: [927 930 945 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*') ($ VSub_DollarName '$x')}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(add_list)} {(_o)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name o>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Percent
                                                  arg_word: {($ VSub_DollarName '$x')}
                                                )
                                              spids: [956 960]
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:o spids:[963])
                                          op: Equal
                                          rhs: (word.EmptyWord)
                                          spids: [963]
                                        )
                                      ]
                                      spids: [963]
                                    )
                                  ]
                                  spids: [948 950 964 16777215]
                                )
                              ]
                              spids: [868 874 967]
                            )
                          ]
                          spids: [865 970]
                        )
                      spids: [857 16777215]
                    )
                  ]
                  spids: [794 973]
                )
              spids: [790 16777215]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:OBJROOTS spids:[976])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$_o'))}
                  spids: [976]
                )
              ]
              spids: [976]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$OBJTOP'))}
              arms: [
                (case_arm
                  pat_list: [{(DQ )}]
                  action: [
                    (command.ForEach
                      iter_name: o
                      iter_words: [{($ VSub_DollarName '$OBJROOTS')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:OBJTOP spids:[1009])
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$o') 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name TARGET_SPEC>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_ColonHyphen
                                            arg_word: {($ VSub_DollarName '$MACHINE')}
                                          )
                                        spids: [1011 1015]
                                      )
                                    }
                                  spids: [1009]
                                )
                              ]
                              spids: [1009]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                          spids: [1006 1021]
                        )
                      spids: [1002 16777215]
                    )
                  ]
                  spids: [992 994 1024 16777215]
                )
              ]
              spids: [983 989 1027]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:src_re spids:[1030])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1030]
                )
              ]
              spids: [1030]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:obj_re spids:[1033])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1033]
                )
              ]
              spids: [1033]
            )
            (C {(add_list)} {(SQ <'|'>)} {(-s)} {(SQ <'/*'>)} {(src_re)} {($ VSub_DollarName '$SRCTOPS')})
            (C {(add_list)} {(SQ <'|'>)} {(-s)} {(SQ <'*'>)} {(obj_re)} {($ VSub_DollarName '$OBJROOTS')})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$RELDIR'))} {(Lit_Other ']')})
                (C {(unset)} {(DPDEPS)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:tf spids:[1089])
                  op: Equal
                  rhs: {(/tmp/m2d) ($ VSub_Dollar '$$') (-) ($ VSub_DollarName '$USER')}
                  spids: [1089]
                )
              ]
              spids: [1089]
            )
            (C {(rm)} {(-f)} {($ VSub_DollarName '$tf') (.) (Lit_Other '*')})
            (C {(trap)} {(SQ <'rm -f $tf.*; trap 0'>)} {(0)})
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$tf') (.dirdep)}
                )
              ]
            )
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$tf') (.qual)}
                )
              ]
            )
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$tf') (.srcdep)}
                )
              ]
            )
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$tf') (.srcrel)}
                )
              ]
            )
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$tf') (.dpdeps)}
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:seenit spids:[1146])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1146]
                )
              ]
              spids: [1146]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:seensrc spids:[1149])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1149]
                )
              ]
              spids: [1149]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:lpid spids:[1152])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1152]
                )
              ]
              spids: [1152]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$EXCLUDES'))}
              arms: [
                (case_arm
                  pat_list: [{(DQ )}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:_excludes spids:[1168])
                          op: Equal
                          rhs: {(cat)}
                          spids: [1168]
                        )
                      ]
                      spids: [1168]
                    )
                  ]
                  spids: [1164 1166 1170 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:_excludes spids:[1176])
                          op: Equal
                          rhs: {(_excludes_f)}
                          spids: [1176]
                        )
                      ]
                      spids: [1176]
                    )
                  ]
                  spids: [1173 1174 1178 16777215]
                )
              ]
              spids: [1155 1161 1181]
            )
            (command.Pipeline
              children: [
                (command.Case
                  to_match: {(DQ ($ VSub_At '$@'))}
                  arms: [
                    (case_arm
                      pat_list: [
                        {(Lit_Other '*') (Lit_Other '@') (Lit_Other '[') (KW_Bang '!') (.) 
                          (Lit_Other ']') (Lit_Other '*')
                        }
                      ]
                      action: [
                        (command.ForEach
                          iter_name: f
                          iter_words: [{(DQ ($ VSub_At '$@'))}]
                          do_arg_iter: F
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$f'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(Lit_Other '*') (.meta)}]
                                      action: [(C {(cat)} {($ VSub_DollarName '$f')})]
                                      spids: [1230 1232 1237 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '@') (Lit_Other '*')}]
                                      action: [
                                        (command.SimpleCommand
                                          words: [{(xargs)} {(cat)}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Less '<'>
                                              fd: 16777215
                                              arg_word: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name f>
                                                    suffix_op: 
                                                      (suffix_op.StringUnary
                                                        op_id: VOp1_Pound
                                                        arg_word: {('@')}
                                                      )
                                                    spids: [1250 1254]
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1240 1242 1255 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [(C {(cat)} {($ VSub_DollarName '$f')})]
                                      spids: [1258 1259 1264 16777215]
                                    )
                                  ]
                                  spids: [1221 1227 1267]
                                )
                              ]
                              spids: [1218 1270]
                            )
                          spids: [1212 16777215]
                        )
                      ]
                      spids: [1197 1204 1273 16777215]
                    )
                    (case_arm
                      pat_list: [{(Lit_Other '*')}]
                      action: [(C {(cat)} {(/dev/null)} {(DQ ($ VSub_At '$@'))})]
                      spids: [1276 1277 1286 16777215]
                    )
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                  spids: [1188 1194 1289]
                )
                (C {(sed)} {(-e)} {(SQ <'s,^CWD,C C,;/^[CREFLM] /!d'>)} {(-e)} {(DQ ("s,',,g"))})
                (C {($ VSub_DollarName '$_excludes')})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(op)} {(pid)} {(path)} {(junk)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(Lit_Other ':')} {(Lit_VarLike 'op=') ($ VSub_DollarName '$op')} 
                          {(Lit_VarLike 'pid=') ($ VSub_DollarName '$pid')} {(Lit_VarLike 'path=') ($ VSub_DollarName '$path')}
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$lpid') (',') ($ VSub_DollarName '$pid'))}
                          arms: [
                            (case_arm
                              pat_list: [{(Lit_Comma ',') (C)}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:CWD spids:[1371])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$path')}
                                      spids: [1371]
                                    )
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:cwd spids:[1374])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$path')}
                                      spids: [1374]
                                    )
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:ldir spids:[1377])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$path')}
                                      spids: [1377]
                                    )
                                  ]
                                  spids: [1371]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$SB'))} 
                                              {(Lit_Other ']')}
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:SB spids:[1397])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSubPart
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {(echo)} {($ VSub_DollarName '$CWD')})
                                                              (C {(sed)} {(SQ <'s,/obj.*,,'>)})
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick '`'>
                                                    spids: [1398 1410]
                                                  )
                                                }
                                              spids: [1397]
                                            )
                                          ]
                                          spids: [1397]
                                        )
                                      ]
                                      spids: [16777215 1394]
                                    )
                                  ]
                                  spids: [16777215 1413]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:SRCTOP spids:[1416])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name SRCTOP>
                                            suffix_op: 
                                              (suffix_op.StringUnary
                                                op_id: VTest_ColonHyphen
                                                arg_word: 
                                                  {($ VSub_DollarName '$SB') (Lit_Slash /) (src)}
                                              )
                                            spids: [1417 1423]
                                          )
                                        }
                                      spids: [1416]
                                    )
                                  ]
                                  spids: [1416]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [1367 1369 1429 16777215]
                            )
                            (case_arm
                              pat_list: [
                                {($ VSub_DollarName '$pid') (Lit_Comma ',') 
                                  ($ VSub_DollarName '$pid')
                                }
                              ]
                              spids: [1432 1435 1437 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$lpid'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(DQ )}]
                                      spids: [1453 1455 1457 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (C {(eval)} 
                                          {(ldir_) ($ VSub_DollarName '$lpid') (Lit_Other '=') 
                                            ($ VSub_DollarName '$ldir')
                                          }
                                        )
                                      ]
                                      spids: [1460 1461 1469 16777215]
                                    )
                                  ]
                                  spids: [1444 1450 1472]
                                )
                                (C {(eval)} 
                                  {(Lit_VarLike 'ldir=') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (Lit_LBrace '{') (ldir_) ($ VSub_DollarName '$pid') (Lit_Other ':') (-) ($ VSub_DollarName '$CWD') 
                                    (Lit_RBrace '}')
                                  } 
                                  {(Lit_VarLike 'cwd=') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (Lit_LBrace '{') (cwd_) ($ VSub_DollarName '$pid') (Lit_Other ':') (-) ($ VSub_DollarName '$CWD') 
                                    (Lit_RBrace '}')
                                  }
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:lpid spids:[1498])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$pid')}
                                      spids: [1498]
                                    )
                                  ]
                                  spids: [1498]
                                )
                              ]
                              spids: [1440 1441 1502 16777215]
                            )
                          ]
                          spids: [1356 1364 1505]
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$op') (',') ($ VSub_DollarName '$path'))}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(W) (Lit_Comma ',') (Lit_Other '*') (srcrel)}
                                {(Lit_Other '*') (.dirdep)}
                              ]
                              action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                              spids: [1520 1527 1530 16777215]
                            )
                            (case_arm
                              pat_list: [{(C) (Lit_Comma ',') (Lit_Other '*')}]
                              action: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$path'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(/) (Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:cwd spids:[1552])
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$path')}
                                              spids: [1552]
                                            )
                                          ]
                                          spids: [1552]
                                        )
                                      ]
                                      spids: [1548 1550 1554 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:cwd spids:[1560])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSubPart
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.AndOr
                                                            ops: [Op_DAmp]
                                                            children: [
                                                              (command.SimpleCommand
                                                                words: [
                                                                  {(cd)}
                                                                  {($ VSub_DollarName '$cwd') (/) 
                                                                    ($ VSub_DollarName '$path')
                                                                  }
                                                                ]
                                                                redirects: [
                                                                  (redir.Redir
                                                                    op: <Redir_Great '2>'>
                                                                    fd: 2
                                                                    arg_word: {(/dev/null)}
                                                                  )
                                                                ]
                                                              )
                                                              (C {(/bin/pwd)})
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_Backtick '`'>
                                                    spids: [1561 1575]
                                                  )
                                                }
                                              spids: [1560]
                                            )
                                          ]
                                          spids: [1560]
                                        )
                                      ]
                                      spids: [1557 1558 1576 16777215]
                                    )
                                  ]
                                  spids: [1539 1545 1579]
                                )
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-d)} 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name cwd>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VTest_ColonHyphen
                                              arg_word: 
                                                {(Lit_Slash /) (dev) (Lit_Slash /) (null) (Lit_Slash /) 
                                                  (no) (Lit_Slash /) (such)
                                                }
                                            )
                                          spids: [1590 1601]
                                        )
                                      }
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:cwd spids:[1605])
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$CWD')}
                                          spids: [1605]
                                        )
                                      ]
                                      spids: [1605]
                                    )
                                  ]
                                )
                                (C {(eval)} 
                                  {(cwd_) ($ VSub_DollarName '$pid') (Lit_Other '=') 
                                    ($ VSub_DollarName '$cwd')
                                  }
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [1533 1536 1620 16777215]
                            )
                            (case_arm
                              pat_list: [{(F) (Lit_Comma ',') (Lit_Other '*')}]
                              action: [
                                (C {(eval)} 
                                  {(cwd_) ($ VSub_DollarName '$path') (Lit_Other '=') 
                                    ($ VSub_DollarName '$cwd')
                                  } {(ldir_) ($ VSub_DollarName '$path') (Lit_Other '=') ($ VSub_DollarName '$ldir')}
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [1623 1626 1648 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:dir spids:[1655])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name path>
                                            suffix_op: 
                                              (suffix_op.StringUnary
                                                op_id: VOp1_Percent
                                                arg_word: {(Lit_Slash /) ('*')}
                                              )
                                            spids: [1656 1661]
                                          )
                                        }
                                      spids: [1655]
                                    )
                                  ]
                                  spids: [1655]
                                )
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$path'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {($ VSub_DollarName '$src_re')}
                                        {($ VSub_DollarName '$obj_re')}
                                      ]
                                      spids: [1673 1676 1678 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(/) (Lit_Other '*') (/stage/) (Lit_Other '*')}]
                                      spids: [1681 1685 1687 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(/) (Lit_Other '*')}]
                                      action: [
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [1690 1692 1695 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (command.ForEach
                                          iter_name: path
                                          iter_words: [
                                            {($ VSub_DollarName '$ldir') (/) 
                                              ($ VSub_DollarName '$path')
                                            }
                                            {($ VSub_DollarName '$cwd') (/) 
                                              ($ VSub_DollarName '$path')
                                            }
                                          ]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-e)} {($ VSub_DollarName '$path')})
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Break break>
                                                    )
                                                  ]
                                                )
                                              ]
                                              spids: [1716 1730]
                                            )
                                          spids: [1706 16777215]
                                        )
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:dir spids:[1733])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name path>
                                                    suffix_op: 
                                                      (suffix_op.StringUnary
                                                        op_id: VOp1_Percent
                                                        arg_word: {(Lit_Slash /) ('*')}
                                                      )
                                                    spids: [1734 1739]
                                                  )
                                                }
                                              spids: [1733]
                                            )
                                          ]
                                          spids: [1733]
                                        )
                                      ]
                                      spids: [1698 1699 1742 16777215]
                                    )
                                  ]
                                  spids: [1664 1670 1745]
                                )
                              ]
                              spids: [1652 1653 1748 16777215]
                            )
                          ]
                          spids: [1509 1517 1751]
                        )
                        (command.Case
                          to_match: 
                            {
                              (DQ ($ VSub_DollarName '$DPDEPS') (',') ($ VSub_DollarName '$seensrc') 
                                (',')
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [{(Lit_Comma ',') (Lit_Other '*')}]
                              action: [
                                (command.Case
                                  to_match: {(DQ (',') ($ VSub_DollarName '$seenit') (','))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(Lit_Other '*') (Lit_Comma ',') ($ VSub_DollarName '$dir') 
                                          (Lit_Comma ',') (Lit_Other '*')
                                        }
                                      ]
                                      action: [
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [1786 1791 1794 16777215]
                                    )
                                  ]
                                  spids: [1775 1783 1797]
                                )
                              ]
                              spids: [1770 1772 1800 16777215]
                            )
                            (case_arm
                              pat_list: [
                                {(Lit_Other '*') (Lit_Comma ',') ($ VSub_DollarName '$path') 
                                  (Lit_Comma ',') (Lit_Other '*')
                                }
                              ]
                              action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                              spids: [1803 1808 1811 16777215]
                            )
                          ]
                          spids: [1758 1767 1814]
                        )
                        (command.Case
                          to_match: {(DQ (/) ($ VSub_DollarName '$dir') (/))}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(Lit_Other '*') (/../) (Lit_Other '*')}
                                {(Lit_Other '*') (/./) (Lit_Other '*')}
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:rdir spids:[1842])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$dir')}
                                      spids: [1842]
                                    )
                                  ]
                                  spids: [1842]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:dir spids:[1846])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.AndOr
                                                    ops: [Op_DAmp]
                                                    children: [
                                                      (command.SimpleCommand
                                                        words: [{(cd)} {($ VSub_DollarName '$dir')}]
                                                        redirects: [
                                                          (redir.Redir
                                                            op: <Redir_Great '2>'>
                                                            fd: 2
                                                            arg_word: {(/dev/null)}
                                                          )
                                                        ]
                                                      )
                                                      (C {(/bin/pwd)})
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick '`'>
                                            spids: [1847 1859]
                                          )
                                        }
                                      spids: [1846]
                                    )
                                  ]
                                  spids: [1846]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:seen spids:[1862])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$rdir') (',') 
                                            ($ VSub_DollarName '$dir')
                                          )
                                        }
                                      spids: [1862]
                                    )
                                  ]
                                  spids: [1862]
                                )
                              ]
                              spids: [1832 1839 1870 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:seen spids:[1876])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$dir')}
                                      spids: [1876]
                                    )
                                  ]
                                  spids: [1876]
                                )
                              ]
                              spids: [1873 1874 1878 16777215]
                            )
                          ]
                          spids: [1821 1829 1881]
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$dir'))}
                          arms: [
                            (case_arm
                              pat_list: [
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name CURDIR>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VTest_ColonHyphen
                                        arg_word: {(.)}
                                      )
                                    spids: [1893 1897]
                                  )
                                }
                                {(DQ )}
                              ]
                              action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                              spids: [1893 1901 1904 16777215]
                            )
                            (case_arm
                              pat_list: [{($ VSub_DollarName '$src_re')}]
                              action: [
                                (command.Case
                                  to_match: 
                                    {
                                      (DQ ($ VSub_DollarName '$DPDEPS') (',') 
                                        ($ VSub_DollarName '$seensrc') (',')
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [{(Lit_Comma ',') (Lit_Other '*')}]
                                      action: [
                                        (command.Case
                                          to_match: {(DQ (',') ($ VSub_DollarName '$seenit') (','))}
                                          arms: [
                                            (case_arm
                                              pat_list: [
                                                {(Lit_Other '*') (Lit_Comma ',') 
                                                  ($ VSub_DollarName '$dir') (Lit_Comma ',') (Lit_Other '*')
                                                }
                                              ]
                                              action: [
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                              spids: [1943 1948 1951 16777215]
                                            )
                                          ]
                                          spids: [1932 1940 1954]
                                        )
                                      ]
                                      spids: [1927 1929 1957 16777215]
                                    )
                                  ]
                                  spids: [1915 1924 1960]
                                )
                              ]
                              spids: [1907 1908 1963 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Case
                                  to_match: {(DQ (',') ($ VSub_DollarName '$seenit') (','))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(Lit_Other '*') (Lit_Comma ',') ($ VSub_DollarName '$dir') 
                                          (Lit_Comma ',') (Lit_Other '*')
                                        }
                                      ]
                                      action: [
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [1981 1986 1989 16777215]
                                    )
                                  ]
                                  spids: [1970 1978 1992]
                                )
                              ]
                              spids: [1966 1967 1995 16777215]
                            )
                          ]
                          spids: [1884 1890 1998]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(Lit_Other '[')} {(-d)} {($ VSub_DollarName '$path')} 
                                      {(Lit_Other ']')}
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$path'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(Lit_Other '*') (/..)}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:ldir spids:[2028])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name dir>
                                                    suffix_op: 
                                                      (suffix_op.StringUnary
                                                        op_id: VOp1_Percent
                                                        arg_word: {(Lit_Slash /) ('*')}
                                                      )
                                                    spids: [2029 2034]
                                                  )
                                                }
                                              spids: [2028]
                                            )
                                          ]
                                          spids: [2028]
                                        )
                                      ]
                                      spids: [2024 2026 2035 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:ldir spids:[2041])
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$path')}
                                              spids: [2041]
                                            )
                                          ]
                                          spids: [2041]
                                        )
                                      ]
                                      spids: [2038 2039 2043 16777215]
                                    )
                                  ]
                                  spids: [2015 2021 2046]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [16777215 2012]
                            )
                          ]
                          spids: [16777215 2052]
                        )
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(Lit_Other '[')} {(-f)} {($ VSub_DollarName '$path')} {(Lit_Other ']')})
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$dir'))}
                          arms: [
                            (case_arm
                              pat_list: [{($ VSub_DollarName '$CWD')}]
                              action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                              spids: [2077 2078 2081 16777215]
                            )
                            (case_arm
                              pat_list: [{($ VSub_DollarName '$src_re')}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:seenit spids:[2091])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$seenit') (',') 
                                            ($ VSub_DollarName '$seen')
                                          )
                                        }
                                      spids: [2091]
                                    )
                                  ]
                                  spids: [2091]
                                )
                                (command.SimpleCommand
                                  words: [{(echo)} {($ VSub_DollarName '$dir')}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_DGreat '>>'>
                                      fd: 16777215
                                      arg_word: {($ VSub_DollarName '$tf') (.srcdep)}
                                    )
                                  ]
                                )
                                (command.Case
                                  to_match: 
                                    {
                                      (DQ ($ VSub_DollarName '$DPDEPS') (',') 
                                        ($ VSub_DollarName '$reldir') (',') ($ VSub_DollarName '$seensrc') (',')
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [{(Lit_Comma ',') (Lit_Other '*')}]
                                      spids: [2123 2125 2127 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:seensrc spids:[2133])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$seensrc') (',') 
                                                    ($ VSub_DollarName '$path')
                                                  )
                                                }
                                              spids: [2133]
                                            )
                                          ]
                                          spids: [2133]
                                        )
                                        (command.SimpleCommand
                                          words: [
                                            {(echo)}
                                            {
                                              (DQ (DPDEPS_) ($ VSub_DollarName '$dir') (/) 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name path>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_DPound
                                                      arg_word: {('*') (Lit_Slash /)}
                                                    )
                                                  spids: [2147 2152]
                                                ) (' += ') ($ VSub_DollarName '$RELDIR')
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_DGreat '>>'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$tf') (.dpdeps)}
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [2130 2131 2163 16777215]
                                    )
                                  ]
                                  spids: [2109 2120 2166]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [2087 2088 2172 16777215]
                            )
                          ]
                          spids: [2068 2074 2175]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(Lit_Other '[')} {(-s)} {($ VSub_DollarName '$path') (.dirdep)} 
                                      {(Lit_Other ']')}
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.SimpleCommand
                                  words: [{(echo)} {($ VSub_DollarName '$path') (.dirdep)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_DGreat '>>'>
                                      fd: 16777215
                                      arg_word: {($ VSub_DollarName '$tf') (.qual)}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [16777215 2198]
                            )
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(Lit_Other '[')} {(-s)} {($ VSub_DollarName '$dir') (.dirdep)} 
                                      {(Lit_Other ']')}
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.SimpleCommand
                                  words: [{(echo)} {($ VSub_DollarName '$dir') (.dirdep)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_DGreat '>>'>
                                      fd: 16777215
                                      arg_word: {($ VSub_DollarName '$tf') (.qual)}
                                    )
                                  ]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:seenit spids:[2249])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$seenit') (',') 
                                            ($ VSub_DollarName '$seen')
                                          )
                                        }
                                      spids: [2249]
                                    )
                                  ]
                                  spids: [2249]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [2223 2235]
                            )
                          ]
                          spids: [16777215 2260]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:seenit spids:[2263])
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_DollarName '$seenit') (',') ($ VSub_DollarName '$seen'))
                                }
                              spids: [2263]
                            )
                          ]
                          spids: [2263]
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$dir'))}
                          arms: [
                            (case_arm
                              pat_list: [{($ VSub_DollarName '$obj_re')}]
                              action: [(C {(echo)} {($ VSub_DollarName '$dir')})]
                              spids: [2280 2281 2287 16777215]
                            )
                          ]
                          spids: [2271 2277 2290]
                        )
                      ]
                      spids: [1333 2293]
                    )
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {($ VSub_DollarName '$tf') (.dirdep)}
                    )
                  ]
                )
              ]
              negated: F
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:_nl spids:[2301])
                  op: Equal
                  rhs: {(echo)}
                  spids: [2301]
                )
              ]
              spids: [2301]
            )
            (command.ForEach
              iter_name: f
              iter_words: [
                {($ VSub_DollarName '$tf') (.dirdep)}
                {($ VSub_DollarName '$tf') (.qual)}
                {($ VSub_DollarName '$tf') (.srcdep)}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(Lit_Other '[')} {(-s)} {($ VSub_DollarName '$f')} {(Lit_Other ']')})
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$f')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (qual)}]
                          action: [
                            (command.Pipeline
                              children: [
                                (command.SimpleCommand
                                  words: [{(xargs)} {(cat)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Less '<'>
                                      fd: 16777215
                                      arg_word: {($ VSub_DollarName '$f')}
                                    )
                                  ]
                                )
                                (C {(sort)} {(-u)})
                                (C {(sed)} 
                                  {
                                    (DQ ('s,^# ,,;s,^,') ($ VSub_DollarName '$OBJTOP') ('/,;s,') 
                                      (Lit_Other '\\') (.) 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name TARGET_SPEC>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_ColonHyphen
                                            arg_word: {($ VSub_DollarName '$MACHINE')}
                                          )
                                        spids: [2397 2401]
                                      ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (',,;s,') (Lit_Other '\\') (.) 
                                      ($ VSub_DollarName '$MACHINE') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (',,')
                                    )
                                  }
                                )
                              ]
                              negated: F
                            )
                          ]
                          spids: [2344 2346 2412 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(C {(sort)} {(-u)} {($ VSub_DollarName '$f')})]
                          spids: [2415 2416 2423 16777215]
                        )
                      ]
                      spids: [2337 2341 2426]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:_nl spids:[2429])
                          op: Equal
                          rhs: {(Lit_Other ':')}
                          spids: [2429]
                        )
                      ]
                      spids: [2429]
                    )
                  ]
                  spids: [2321 2433]
                )
              spids: [2310 16777215]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-s)} {($ VSub_DollarName '$tf') (.dpdeps)} 
                          {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$DPDEPS'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (/) (Lit_Other '*')}]
                          spids: [2460 2463 2465 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.SimpleCommand
                              words: [{(echo)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {($ VSub_DollarName '$DPDEPS')}
                                )
                              ]
                            )
                          ]
                          spids: [2468 2469 2476 16777215]
                        )
                      ]
                      spids: [2451 2457 2482]
                    )
                    (command.Pipeline
                      children: [
                        (C {(sort)} {(-u)} {($ VSub_DollarName '$tf') (.dpdeps)})
                        (command.SimpleCommand
                          words: [
                            {(sed)}
                            {
                              (DQ ('s,') (${ VSub_Name SRCTOP) ('/,,;s,') 
                                (word_part.BracedVarSub
                                  token: <VSub_Name SB_BACKING_SB>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VTest_ColonHyphen
                                      arg_word: {($ VSub_DollarName '$SB')}
                                    )
                                  spids: [2503 2507]
                                ) ('/src/,,')
                              )
                            }
                          ]
                          redirects: [
                            (redir.Redir
                              op: <Redir_DGreat '>>'>
                              fd: 16777215
                              arg_word: {($ VSub_DollarName '$DPDEPS')}
                            )
                          ]
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [16777215 2448]
                )
              ]
              spids: [16777215 2516]
            )
            (C {($ VSub_DollarName '$_nl')})
          ]
          spids: [563]
        )
      spids: [559 562]
    )
    (command.Case
      to_match: {(/) ($ VSub_Number '$0')}
      arms: [
        (case_arm
          pat_list: [{(Lit_Other '*') (/meta2dep) (Lit_Other '*')}]
          action: [(C {(meta2deps)} {(DQ ($ VSub_At '$@'))})]
          spids: [2535 2538 2545 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*') (/meta2dirs) (Lit_Other '*')}]
          action: [(C {(meta2dirs)} {(DQ ($ VSub_At '$@'))})]
          spids: [2547 2550 2557 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*') (/meta2src) (Lit_Other '*')}]
          action: [(C {(meta2src)} {(DQ ($ VSub_At '$@'))})]
          spids: [2559 2562 2569 16777215]
        )
      ]
      spids: [2528 2533 2571]
    )
  ]
)