(command.CommandList
  children: [
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>} {<convert>} {<mam>} {<to>} {<old>} {<make>} {<makefile>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <convert>
      name: convert
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <typeset>
                  more_env: []
                  words: [{<typeset>} {<Id.Lit_VarLike 'buf='> ($ Id.VSub_Star '*')}]
                  redirects: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Simple
              blame_tok: <typeset>
              more_env: []
              words: [{<typeset>} {<-i>} {<i>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [
                {<set>}
                {<-s>}
                {<-A>}
                {<variable>}
                {
                  (BracedVarSub
                    left: <Id.Left_DollarBrace '${'>
                    token: <Id.VSub_Name variable>
                    var_name: variable
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    right: <Id.Right_DollarBrace '}'>
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.ForExpr
              keyword: <Id.KW_For for>
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: ($ Id.Lit_ArithVarLike i)
                  right: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Minus
                      left: 
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name variable>
                            var_name: variable
                            prefix_op: <Id.VSub_Pound '#'>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                      right: {<Id.Lit_Digits 1>}
                    )
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_GreatEqual
                  left: ($ Id.Lit_ArithVarLike i)
                  right: {<Id.Lit_Digits 0>}
                )
              update: 
                (arith_expr.UnaryAssign
                  op_id: Id.Node_PostDMinus
                  child: ($ Id.Lit_ArithVarLike i)
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'buf='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'buf='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'buf='> name:buf)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name buf>
                                    var_name: buf
                                    suffix_op: 
                                      (suffix_op.PatSub
                                        pat: 
                                          {
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) 
                                            (BracedVarSub
                                              left: <Id.Left_DollarBrace '${'>
                                              token: <Id.VSub_Name variable>
                                              var_name: variable
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: ($ Id.Lit_ArithVarLike i)
                                                )
                                              right: <Id.Right_DollarBrace '}'>
                                            )
                                          }
                                        replace: 
                                          {
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'('> 
                                            (BracedVarSub
                                              left: <Id.Left_DollarBrace '${'>
                                              token: <Id.VSub_Name variable>
                                              var_name: variable
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: ($ Id.Lit_ArithVarLike i)
                                                )
                                              right: <Id.Right_DollarBrace '}'>
                                            ) <')'>
                                          }
                                        replace_mode: Id.Lit_Slash
                                        slash_tok: <Id.VOp2_Slash _>
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [{<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName buf))}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <closure>
      name: closure
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <typeset>
              more_env: []
              words: [{<typeset>} {<i>} {<j>}]
              redirects: []
              do_fork: T
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [i]
              iterable: (for_iter__Args)
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ <' '> ($ Id.VSub_DollarName list) <' '>)}
                              right: 
                                {<Id.Lit_Other '*'> (DQ <' '> ($ Id.VSub_DollarName i) <' '>) 
                                  <Id.Lit_Other '*'>
                                }
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Continue continue>
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'list='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'list='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'list='> name:list)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName list) <' '> ($ Id.VSub_DollarName i))}
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [j]
                      iterable: 
                        (for_iter.Words
                          words: [
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name implicit>
                                var_name: implicit
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName i)})
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          ]
                        )
                      body: 
                        (command.DoGroup
                          left: <Id.KW_Do do>
                          children: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  blame_tok: <closure>
                                  more_env: []
                                  words: [{<closure>} {($ Id.VSub_DollarName j)}]
                                  redirects: []
                                  do_fork: T
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <typeset>
      more_env: []
      words: [{<typeset>} {<-A>} {<prereqs>} {<implicit>} {<action>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <typeset>
      more_env: []
      words: [{<typeset>} {<-i>} {<Id.Lit_VarLike 'level='> <0>} {<Id.Lit_VarLike 'nvariables='> <0>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <typeset>
      more_env: []
      words: [{<typeset>} {<rule>} {<list>} {<order>} {<target>} {<variable>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <print>
      more_env: []
      words: [{<print>} {(DQ <'# # oldmake makefile generated by '> ($ Id.VSub_Number 0) <' # #'>)}]
      redirects: []
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <read>
              more_env: []
              words: [{<read>} {<-r>} {<op>} {<arg>} {<val>} {<extra>} {<junk>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName op)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_LBracket '['>
                  pattern: 
                    (pat.Words
                      words: [{<Id.Lit_LBracket '['> <0-9> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'op='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'op='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName arg)}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'arg='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'arg='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName val)}
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'val='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'val='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'val='> name:val)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName extra)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName op)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <setv>
                  pattern: (pat.Words words:[{<setv>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_ArrayLhsOpen 'variable['>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_ArrayLhsOpen 'variable['>
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen 'variable['>
                              name: variable
                              index: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: ($ Id.Lit_ArithVarLike nvariables)
                                )
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName arg)}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <convert>
                      more_env: []
                      words: [
                        {<convert>}
                        {(DQ ($ Id.VSub_DollarName arg) <' = '> ($ Id.VSub_DollarName val))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <make>
                  pattern: (pat.Words words:[{<make>} {<prev>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rule='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rule='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rule='> name:rule)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name target>
                                var_name: target
                                bracket_op: (bracket_op.ArrayIndex expr:($ Id.Lit_ArithVarLike level))
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ <' '> ($ Id.VSub_DollarName val) <' '>)}
                              right: {<Id.Lit_Other '*'> (DQ <' implicit '>) <Id.Lit_Other '*'>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_ArrayLhsOpen 'implicit['>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_ArrayLhsOpen 'implicit['>
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  left: <Id.Lit_ArrayLhsOpen 'implicit['>
                                  name: implicit
                                  index: {($ Id.VSub_DollarName rule)}
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      left: <Id.Left_DollarBrace '${'>
                                      token: <Id.VSub_Name implicit>
                                      var_name: implicit
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: {($ Id.VSub_DollarName rule)}
                                        )
                                      right: <Id.Right_DollarBrace '}'>
                                    ) <' '> ($ Id.VSub_DollarName arg)
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_ArrayLhsOpen 'prereqs['>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_ArrayLhsOpen 'prereqs['>
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  left: <Id.Lit_ArrayLhsOpen 'prereqs['>
                                  name: prereqs
                                  index: {($ Id.VSub_DollarName rule)}
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      left: <Id.Left_DollarBrace '${'>
                                      token: <Id.VSub_Name prereqs>
                                      var_name: prereqs
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: {($ Id.VSub_DollarName rule)}
                                        )
                                      right: <Id.Right_DollarBrace '}'>
                                    ) <' '> ($ Id.VSub_DollarName arg)
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                      ]
                      ops: [<Id.Op_DAmp _> <Id.Op_DPipe _>]
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName op)}
                              right: {<prev>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Continue continue>
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                    (command.ShAssignment
                      left: <Id.Lit_ArrayLhsOpen 'target['>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_ArrayLhsOpen 'target['>
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen 'target['>
                              name: target
                              index: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Arith_DPlus
                                  child: ($ Id.Lit_ArithVarLike level)
                                )
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName arg)}
                        )
                      ]
                      redirects: []
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ <' '> ($ Id.VSub_DollarName order) <' '>)}
                              right: 
                                {<Id.Lit_Other '*'> (DQ <' '> ($ Id.VSub_DollarName arg) <' '>) 
                                  <Id.Lit_Other '*'>
                                }
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'order='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'order='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'order='> name:order)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName order) <' '> ($ Id.VSub_DollarName arg))}
                            )
                          ]
                          redirects: []
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <exec>
                  pattern: (pat.Words words:[{<exec>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName arg)}
                              right: {<->}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'arg='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'arg='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name target>
                                    var_name: target
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: ($ Id.Lit_ArithVarLike level)
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.WordTest
                              w: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name action>
                                    var_name: action
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName arg)}
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_ArrayLhsOpen 'action['>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_ArrayLhsOpen 'action['>
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  left: <Id.Lit_ArrayLhsOpen 'action['>
                                  name: action
                                  index: {($ Id.VSub_DollarName arg)}
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name action>
                                    var_name: action
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName arg)}
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  ) 
                                  (SingleQuoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\n'>]
                                    right: <Id.Right_SingleQuote '\''>
                                  ) 
                                  (SingleQuoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\t'>]
                                    right: <Id.Right_SingleQuote '\''>
                                  ) ($ Id.VSub_DollarName val)
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ShAssignment
                          left: <Id.Lit_ArrayLhsOpen 'action['>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_ArrayLhsOpen 'action['>
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  left: <Id.Lit_ArrayLhsOpen 'action['>
                                  name: action
                                  index: {($ Id.VSub_DollarName arg)}
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (SingleQuoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\t'>]
                                    right: <Id.Right_SingleQuote '\''>
                                  ) ($ Id.VSub_DollarName val)
                                }
                            )
                          ]
                          redirects: []
                        )
                      ]
                      ops: [<Id.Op_DAmp _> <Id.Op_DPipe _>]
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.KW_Done done>
                  pattern: (pat.Words words:[{<Id.KW_Done done>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'level='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'level='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'level='> name:level)
                          op: assign_op.Equal
                          rhs: {<level-1>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [rule]
      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName order)}])
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.AndOr
              children: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.WordTest
                              w: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name prereqs>
                                    var_name: prereqs
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName rule)}
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                        )
                      right: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.WordTest
                              w: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name action>
                                    var_name: action
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName rule)}
                                      )
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                            )
                        )
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'list='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'list='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'list='> name:list)
                  op: assign_op.Equal
                  rhs: (rhs_word__Empty)
                )
              ]
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <closure>
                  more_env: []
                  words: [
                    {<closure>}
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name prereqs>
                        var_name: prereqs
                        bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName rule)})
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <print>
                  more_env: []
                  words: [{<print>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <convert>
                  more_env: []
                  words: [
                    {<convert>}
                    {(DQ ($ Id.VSub_DollarName rule) <' :'> ($ Id.VSub_DollarName list))}
                  ]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _> <Id.Op_DAmp _>]
            )
            (command.AndOr
              children: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.WordTest
                      w: 
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name action>
                            var_name: action
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName rule)})
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
                (command.Simple
                  blame_tok: <convert>
                  more_env: []
                  words: [
                    {<convert>}
                    {
                      (DQ 
                        (BracedVarSub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Name action>
                          var_name: action
                          bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName rule)})
                          right: <Id.Right_DollarBrace '}'>
                        )
                      )
                    }
                  ]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
  ]
)