(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:errors)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [10]
        )
      ]
    )
    (command.ShFunction
      name: test_diffs
      body: 
        (BraceGroup
          children: [
            (C {<mv>} {<-f>} {($ Id.VSub_DollarName '$NEW')} {(${ Id.VSub_Name REF_DIR) <'/'>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:CMP)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name REF_DIR) <'/'> (${ Id.VSub_Name NEW)}
                  spids: [43]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<Id.KW_Bang '!'>} {<-f>} {($ Id.VSub_DollarName '$CMP')})]
                    )
                  action: [
                    (C {<echo>} {(DQ <'...not found '> ($ Id.VSub_DollarName '$CMP'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:errors)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [75]
                        )
                      ]
                    )
                  ]
                  spids: [53 64]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (command.Simple
                      words: [
                        {<sed>}
                        {<-e>}
                        {<s> <Id.Lit_Comma ','> ($ Id.VSub_DollarName '$NEW') <Id.Lit_Comma ','> 
                          ($ Id.VSub_DollarName '$REF') <Id.Lit_Comma ','>
                        }
                        {<-e>}
                        {(DQ <'s%'> ($ Id.VSub_DollarName '$YACC_escaped') <'%YACC%'>)}
                        {<-e>}
                        {(SQ <'/YYPATCH/s/[0-9][0-9]*/"yyyymmdd"/'>)}
                        {<-e>}
                        {(SQ <'/#define YYPATCH/s/PATCH/CHECK/'>)}
                        {<-e>}
                        {(SQ <'s,#line \\([1-9][0-9]*\\) "'>) ($ Id.VSub_DollarName '$REF_DIR') 
                          (SQ <'/,#line \\1 ",'>)
                        }
                        {<-e>}
                        {(SQ <'s,#line \\([1-9][0-9]*\\) "'>) ($ Id.VSub_DollarName '$TEST_DIR') 
                          (SQ <'/,#line \\1 ",'>)
                        }
                        {<-e>}
                        {(SQ <'s,\\(YACC:.* line [0-9][0-9]* of "\\)'>) 
                          ($ Id.VSub_DollarName '$TEST_DIR') <'/'> (SQ <',\\1./,'>)
                        }
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {($ Id.VSub_DollarName '$CMP')}
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {($ Id.VSub_DollarName '$tmpfile')}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<mv>} {($ Id.VSub_DollarName '$tmpfile')} {($ Id.VSub_DollarName '$CMP')})
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<test>} {<Id.KW_Bang '!'>} {<-f>} {($ Id.VSub_DollarName '$REF')})
                          ]
                        )
                      action: [
                        (C {<mv>} {($ Id.VSub_DollarName '$CMP')} {($ Id.VSub_DollarName '$REF')})
                        (C {<echo>} {(DQ <'...saved '> ($ Id.VSub_DollarName '$REF'))})
                      ]
                      spids: [176 187]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Subshell
                              child: 
                                (C {<cmp>} {<-s>} {($ Id.VSub_DollarName '$REF')} 
                                  {($ Id.VSub_DollarName '$CMP')}
                                )
                            )
                          ]
                        )
                      action: [
                        (C {<echo>} {(DQ <'...ok '> ($ Id.VSub_DollarName '$REF'))})
                        (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$CMP')})
                      ]
                      spids: [205 220]
                    )
                  ]
                  else_action: [
                    (C {<echo>} {(DQ <'...diff '> ($ Id.VSub_DollarName '$REF'))})
                    (C {<diff>} {<-u>} {($ Id.VSub_DollarName '$REF')} {($ Id.VSub_DollarName '$CMP')})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:errors)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [258]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_flags
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(DQ <'** testing flags '> ($ Id.VSub_Star '$*'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:root)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [285]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ROOT)
                  op: assign_op.Equal
                  rhs: {<test-> ($ Id.VSub_DollarName '$root')}
                  spids: [289]
                )
              ]
            )
            (C {<shift>} {<1>})
            (command.Simple
              words: [{($ Id.VSub_DollarName '$YACC')} {($ Id.VSub_Star '$*')}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$ROOT') <.output>}
                )
                (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$ROOT') <.error>}
                )
              ]
              do_fork: T
            )
            (command.ForEach
              iter_names: [type]
              iterable: (for_iter.Words words:[{<.output>} {<.error>}])
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:NEW)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$ROOT') ($ Id.VSub_DollarName '$type')}
                          spids: [331]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:REF)
                          op: assign_op.Equal
                          rhs: 
                            {($ Id.VSub_DollarName '$REF_DIR') <'/'> ($ Id.VSub_DollarName '$root') 
                              ($ Id.VSub_DollarName '$type')
                            }
                          spids: [336]
                        )
                      ]
                    )
                    (C {<test_diffs>})
                  ]
                )
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [(C {<test>} {($ Id.VSub_Pound '$#')} {<Id.Lit_Equals '='>} {<1>})]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PROG_DIR)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<pwd>}))}
                  spids: [364]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_DIR)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [372]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PROG_DIR)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$PROG_DIR'))})
                              (C {<sed>} {<-e>} {(SQ <'s/ /\\\\ /g'>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [376]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_DIR)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$TEST_DIR'))})
                              (C {<sed>} {<-e>} {(SQ <'s/ /\\\\ /g'>)})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [401]
                )
              ]
            )
          ]
          spids: [351 361]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:PROG_DIR)
              op: assign_op.Equal
              rhs: {<..>}
              spids: [428]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TEST_DIR)
              op: assign_op.Equal
              rhs: {<.>}
              spids: [432]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:YACC)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$PROG_DIR') <'/yacc'>}
          spids: [438]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:YACC_escaped)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<echo>} {(DQ ($ Id.VSub_DollarName '$PROG_DIR') <'/yacc'>)})
                      (C {<sed>} {<-e>} {(SQ <'s/\\./\\\\./g'>)})
                    ]
                    negated: F
                  )
              )
            }
          spids: [442]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:tmpfile)
          op: assign_op.Equal
          rhs: {<temp> ($ Id.VSub_Dollar '$$')}
          spids: [470]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ifBTYACC)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.CommandList
                    children: [
                      (command.Sentence
                        child: 
                          (command.Simple
                            words: [
                              {<fgrep>}
                              {<-l>}
                              {(SQ <'define YYBTYACC'>)}
                              {($ Id.VSub_DollarName '$PROG_DIR') <'/config.h'>}
                            ]
                            redirects: [
                              (redir
                                op: <Id.Redir_Great '>'>
                                loc: (redir_loc.Fd fd:1)
                                arg: {<'/dev/null'>}
                              )
                            ]
                            do_fork: T
                          )
                        terminator: <Id.Op_Semi _>
                      )
                      (command.Sentence
                        child: 
                          (C {<test>} {($ Id.VSub_QMark '$?')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                            {<0>}
                          )
                        terminator: <Id.Op_Semi _>
                      )
                      (C {<echo>} {($ Id.VSub_QMark '$?')})
                    ]
                  )
              )
            }
          spids: [475]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {($ Id.VSub_DollarName '$ifBTYACC')} {<Id.Lit_Equals '='>} {<0>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:REF_DIR)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name TEST_DIR) <'/yacc'>}
                  spids: [525]
                )
              ]
            )
          ]
          spids: [511 522]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:REF_DIR)
              op: assign_op.Equal
              rhs: {(${ Id.VSub_Name TEST_DIR) <'/btyacc'>}
              spids: [534]
            )
          ]
        )
      ]
    )
    (C {<rm>} {<-f>} {(${ Id.VSub_Name REF_DIR) <'/test-'> <Id.Lit_Star '*'>})
    (C {<echo>} {(SQ <'** '>) (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<date>}))})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:MYFILE)
          op: assign_op.Equal
          rhs: {<nosuchfile>}
          spids: [569]
        )
      ]
    )
    (C {<test_flags>} {<help>} {<-z>})
    (C {<test_flags>} {<big_b>} {<-B>})
    (C {<test_flags>} {<big_l>} {<-L>})
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<nostdin>} {<->} {($ Id.VSub_DollarName '$MYFILE') <.y>})
    (C {<test_flags>} {<no_opts>} {<-->} {($ Id.VSub_DollarName '$MYFILE') <.y>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.y>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.c>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_b_opt>} {<-b>})
    (C {<test_flags>} {<no_b_opt1>} {<-bBASE>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.c>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_p_opt>} {<-p>})
    (C {<test_flags>} {<no_p_opt1>} {<-pBASE>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<rm>} {<-f>} {<BASE> ($ Id.VSub_DollarName '$MYFILE') <.c>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.dot>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_graph>} {<-g>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.dot>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.output>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_verbose>} {<-v>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<test_flags>} {<no_output>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.output>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<test_flags>} {<no_output1>} {<-o> ($ Id.VSub_DollarName '$MYFILE') <.output>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<test_flags>} {<no_output2>} {<-o>})
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.output>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.h>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_defines>} {<-d>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.h>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.i>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_include>} {<-i>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.i>})
    (C {<touch>} {($ Id.VSub_DollarName '$MYFILE') <.code.c>})
    (C {<chmod>} {<444>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (C {<test_flags>} {<no_code_c>} {<-r>} {<-o>} {($ Id.VSub_DollarName '$MYFILE') <.c>} 
      {($ Id.VSub_DollarName '$MYFILE') <.y>}
    )
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.code.c>})
    (C {<rm>} {<-f>} {($ Id.VSub_DollarName '$MYFILE') <.> <Id.Lit_Star '*'>})
    (command.ForEach
      iter_names: [input]
      iterable: (for_iter.Words words:[{(${ Id.VSub_Name TEST_DIR) <'/'> <Id.Lit_Star '*'> <.y>}])
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_DollarName '$input')}
              arms: [
                (case_arm
                  pat_list: [{<test-> <Id.Lit_Star '*'>}]
                  action: [(C {<echo>} {(DQ <'?? ignored '> ($ Id.VSub_DollarName '$input'))})]
                  spids: [942 944 955 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:root)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: (C {<basename>} {($ Id.VSub_DollarName '$input')} {<.y>})
                              )
                            }
                          spids: [962]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ROOT)
                          op: assign_op.Equal
                          rhs: {(DQ <test-> ($ Id.VSub_DollarName '$root'))}
                          spids: [974]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:prefix)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name root) <Id.Lit_Underscore _>}
                          spids: [981]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:OPTS)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [989]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:OPT2)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [992]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:OOPT)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [995]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TYPE)
                          op: assign_op.Equal
                          rhs: {(DQ <'.error .output .tab.c .tab.h'>)}
                          spids: [998]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$input')}
                      arms: [
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/btyacc_'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<test>} {($ Id.VSub_DollarName '$ifBTYACC')} 
                                              {<Id.Lit_Equals '='>} {<0>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  spids: [1019 1030]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPTS)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTS') <' -B'>)}
                                  spids: [1038]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prefix)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$prefix'))})
                                              (C {<sed>} {<-e>} {(SQ <'s/^btyacc_//'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  spids: [1045]
                                )
                              ]
                            )
                          ]
                          spids: [1011 1016 1067 -1]
                        )
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/grammar'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPTS)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTS') <' -g'>)}
                                  spids: [1078]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:TYPE)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$TYPE') <' .dot'>)}
                                  spids: [1085]
                                )
                              ]
                            )
                          ]
                          spids: [1070 1075 1092 -1]
                        )
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/code_debug'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPTS)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTS') <' -t -i'>)}
                                  spids: [1103]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OOPT)
                                  op: assign_op.Equal
                                  rhs: {<rename_debug.c>}
                                  spids: [1110]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:TYPE)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$TYPE') <' .i'>)}
                                  spids: [1114]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prefix)
                                  op: assign_op.Equal
                                  rhs: (word.Empty)
                                  spids: [1121]
                                )
                              ]
                            )
                          ]
                          spids: [1095 1100 1124 -1]
                        )
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/code_'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPTS)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTS') <' -r'>)}
                                  spids: [1135]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:TYPE)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$TYPE') <' .code.c'>)}
                                  spids: [1142]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prefix)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$prefix'))})
                                              (C {<sed>} {<-e>} {(SQ <'s/^code_//'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  spids: [1149]
                                )
                              ]
                            )
                          ]
                          spids: [1127 1132 1171 -1]
                        )
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/pure_'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPTS)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTS') <' -P'>)}
                                  spids: [1182]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prefix)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$prefix'))})
                                              (C {<sed>} {<-e>} {(SQ <'s/^pure_//'>)})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  spids: [1189]
                                )
                              ]
                            )
                          ]
                          spids: [1174 1179 1211 -1]
                        )
                        (case_arm
                          pat_list: [{(${ Id.VSub_Name TEST_DIR) <'/quote_'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OPT2)
                                  op: assign_op.Equal
                                  rhs: {(DQ <-s>)}
                                  spids: [1222]
                                )
                              ]
                            )
                          ]
                          spids: [1214 1219 1228 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(${ Id.VSub_Name TEST_DIR) <'/inherit'> <Id.Lit_Star '*'>}
                            {(${ Id.VSub_Name TEST_DIR) <'/err_inherit'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<test>} {($ Id.VSub_DollarName '$ifBTYACC')} 
                                              {<Id.Lit_Equals '='>} {<0>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  spids: [1247 1258]
                                )
                              ]
                            )
                          ]
                          spids: [1231 1244 1266 -1]
                        )
                      ]
                    )
                    (C {<echo>} {(DQ <'** testing '> ($ Id.VSub_DollarName '$input'))})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$prefix'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:prefix)
                              op: assign_op.Equal
                              rhs: {(DQ <'-p '> ($ Id.VSub_DollarName '$prefix'))}
                              spids: [1292]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_names: [opt2]
                      iterable: (for_iter.Words words:[{(DQ )} {($ Id.VSub_DollarName '$OPT2')}])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:output)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$OOPT')}
                                  spids: [1315]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$output'))})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:output)
                                          op: assign_op.Equal
                                          rhs: {(DQ <'-o '> ($ Id.VSub_DollarName '$output'))}
                                          spids: [1333]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:error)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: 
                                                  (C {<basename>} {($ Id.VSub_DollarName '$OOPT')} 
                                                    {<.c>}
                                                  )
                                              ) <.error>
                                            }
                                          spids: [1340]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1319 1330]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:error)
                                      op: assign_op.Equal
                                      rhs: {(${ Id.VSub_Name ROOT) (${ Id.VSub_Name opt2) <.error>}
                                      spids: [1356]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Simple
                              words: [
                                {($ Id.VSub_DollarName '$YACC')}
                                {($ Id.VSub_DollarName '$OPTS')}
                                {($ Id.VSub_DollarName '$opt2')}
                                {<-v>}
                                {<-d>}
                                {($ Id.VSub_DollarName '$output')}
                                {($ Id.VSub_DollarName '$prefix')}
                                {<-b>}
                                {($ Id.VSub_DollarName '$ROOT') (${ Id.VSub_Name opt2)}
                                {($ Id.VSub_DollarName '$input')}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {($ Id.VSub_DollarName '$error')}
                                )
                              ]
                              do_fork: T
                            )
                            (command.ForEach
                              iter_names: [type]
                              iterable: (for_iter.Words words:[{($ Id.VSub_DollarName '$TYPE')}])
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:REF)
                                          op: assign_op.Equal
                                          rhs: 
                                            {(${ Id.VSub_Name REF_DIR) <'/'> (${ Id.VSub_Name root) 
                                              (${ Id.VSub_Name opt2) (${ Id.VSub_Name type)
                                            }
                                          spids: [1409]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$OOPT'))})
                                              ]
                                            )
                                          action: [
                                            (command.Case
                                              to_match: {($ Id.VSub_DollarName '$type')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{<Id.Lit_Star '*'> <.tab.c>}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:type)
                                                          op: assign_op.Equal
                                                          rhs: {<.c>}
                                                          spids: [1456]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [1451 1453 1460 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<Id.Lit_Star '*'> <.tab.h>}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:type)
                                                          op: assign_op.Equal
                                                          rhs: {<.h>}
                                                          spids: [1468]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [1463 1465 1472 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<Id.Lit_Star '*'>}]
                                                  spids: [1475 1476 1479 -1]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:NEW)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_Backtick '`'>
                                                        child: 
                                                          (C {<basename>} 
                                                            {($ Id.VSub_DollarName '$OOPT')} {<.c>}
                                                          )
                                                      ) (${ Id.VSub_Name type)
                                                    }
                                                  spids: [1485]
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: {($ Id.VSub_DollarName '$NEW')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{<test-> <Id.Lit_Star '*'>}]
                                                  spids: [1507 1509 1512 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<Id.Lit_Star '*'>}]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (C {<test>} {<-f>} 
                                                                  {(DQ ($ Id.VSub_DollarName '$NEW'))}
                                                                )
                                                              ]
                                                            )
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:REF)
                                                                  op: assign_op.Equal
                                                                  rhs: 
                                                                    {(${ Id.VSub_Name REF_DIR) <'/'> 
                                                                      ($ Id.VSub_DollarName '$NEW')
                                                                    }
                                                                  spids: [1533]
                                                                )
                                                              ]
                                                            )
                                                            (C {<mv>} {($ Id.VSub_DollarName '$NEW')} 
                                                              {<test-> ($ Id.VSub_DollarName '$NEW')}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:NEW)
                                                                  op: assign_op.Equal
                                                                  rhs: 
                                                                    {<test-> 
                                                                      ($ Id.VSub_DollarName '$NEW')
                                                                    }
                                                                  spids: [1549]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          spids: [1519 1530]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [1515 1516 1557 -1]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [1430 1441]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:NEW)
                                              op: assign_op.Equal
                                              rhs: 
                                                {(${ Id.VSub_Name ROOT) (${ Id.VSub_Name opt2) 
                                                  (${ Id.VSub_Name type)
                                                }
                                              spids: [1566]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {<test_diffs>})
                                  ]
                                )
                            )
                          ]
                        )
                    )
                  ]
                  spids: [958 959 1590 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ControlFlow
      token: <Id.ControlFlow_Exit exit>
      arg_word: {($ Id.VSub_DollarName '$errors')}
    )
  ]
)