(command.CommandList
  children: [
    (command.ShFunction
      name: err_exit
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<print>} {<-u2>} {<-r>} 
              {
                (single_quoted
                  left: <Id.Left_DollarSingleQuote '$\''>
                  tokens: [<Id.Char_OneChar '\\t'>]
                  right: <Id.Right_SingleQuote '\''>
                ) 
                (DQ (${ Id.VSub_Name Command) <'['> ($ Id.VSub_Number 1) <'] '> 
                  (braced_var_sub
                    left: <Id.Left_DollarBrace '${'>
                    token: <Id.VSub_At '@'>
                    var_name: '@'
                    suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 2>})
                    right: <Id.Arith_RBrace _>
                  )
                )
              }
            )
            (command.DParen
              child: 
                (arith_expr.UnaryAssign
                  op_id: Id.Node_PostDPlus
                  child: ($ Id.Lit_ArithVarLike errors)
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<alias>} {<Id.Lit_VarLike 'err_exit='> (SQ <'err_exit $LINENO'>)})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'Command='> name:Command)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Number 0>
                var_name: 0
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_DPound '##'>
                    arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [104]
        )
      ]
      redirects: []
    )
    (C {<integer>} {<Id.Lit_VarLike 'aware='> <0>} {<Id.Lit_VarLike 'contrary='> <0>} 
      {<Id.Lit_VarLike 'errors='> <0>} {<Id.Lit_VarLike 'ignorant='> <0>}
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tmp='> name:tmp)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: (C {<mktemp>} {<-dt>})
                    right: <Id.Eof_RParen _>
                  )
                }
              spids: [127]
            )
          ]
          redirects: []
        )
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: (C {<err_exit>} {<mktemp>} {<-dt>} {<failed>})
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
      ]
    )
    (C {<trap>} {(DQ <'cd /; rm -rf '> ($ Id.VSub_DollarName tmp))} {<EXIT>})
    (command.ShFunction
      name: test_glob
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<typeset>} {<lineno>} {<expected>} {<drop>} {<arg>} {<got>} {<sep>} {<op>} {<val>} {<add>} 
              {<del>}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lineno='> name:lineno)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [194]
                )
              ]
              redirects: []
            )
            (C {<shift>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_Number 1)}
                              right: {<--> <Id.Lit_Other '*'>}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'del='> name:del)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Number 1>
                                var_name: 1
                                suffix_op: (suffix_op.Unary op:<Id.VOp1_Pound '#'> arg_word:{<-->})
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          spids: [217]
                        )
                      ]
                      redirects: []
                    )
                    (C {<shift>})
                  ]
                  spids: [201 215]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_Number 1)}
                              right: {<Id.Lit_Other '+'> <Id.Lit_Other '+'> <Id.Lit_Other '*'>}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'add='> name:add)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Number 1>
                                var_name: 1
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Pound '#'>
                                    arg_word: {<Id.Lit_Other '+'> <Id.Lit_Other '+'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          spids: [248]
                        )
                      ]
                      redirects: []
                    )
                    (C {<shift>})
                  ]
                  spids: [231 246]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expected='> name:expected)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [263]
                )
              ]
              redirects: []
            )
            (C {<shift>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(command.DParen child:($ Id.Lit_ArithVarLike contrary) redirects:[])]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName expected)}
                                      right: {(DQ <'<Beware> '>) <Id.Lit_Other '*'>}
                                    )
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'expected='>
                                      name: expected
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name expected>
                                        var_name: expected
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {(DQ <'<Beware> '>)}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [300]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'expected='>
                                      name: expected
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName expected) <' <Beware>'>)}
                                  spids: [310]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [282 298]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName expected)}
                                      right: 
                                        {<Id.Lit_Other '*'> (DQ <'<aXb> <abd>'>) <Id.Lit_Other '*'>}
                                    )
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'expected='>
                                      name: expected
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name expected>
                                        var_name: expected
                                        suffix_op: 
                                          (suffix_op.PatSub
                                            pat: {(DQ <'<aXb> <abd>'>)}
                                            replace: {(DQ <'<abd> <aXb>'>)}
                                            replace_mode: Id.Undefined_Tok
                                            slash_tok: <Id.VOp2_Slash _>
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [339]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [320 337]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [270 280]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.ForEach
              iter_names: [arg]
              iterable: (for_iter.Args)
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'got='> name:got)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName got) ($ Id.VSub_DollarName sep) <'<'> 
                                ($ Id.VSub_DollarName arg) <'>'>
                              )
                            }
                          spids: [366]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sep='> name:sep)
                          op: assign_op.Equal
                          rhs: {(DQ <' '>)}
                          spids: [376]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_DAmp
                              left: ($ Id.Lit_ArithVarLike ignorant)
                              right: ($ Id.Lit_ArithVarLike aware)
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName del)})
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'got='> name:got)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'<'> ($ Id.VSub_DollarName del) <'> '> 
                                        ($ Id.VSub_DollarName got)
                                      )
                                    }
                                  spids: [412]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [401 410]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName add)})
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'expected='>
                                      name: expected
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'<'> ($ Id.VSub_DollarName add) <'> '> 
                                        ($ Id.VSub_DollarName expected)
                                      )
                                    }
                                  spids: [435]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [424 433]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [385 399]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName got)}
                              right: {(DQ ($ Id.VSub_DollarName expected))}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (C {(SQ <err_exit>)} {($ Id.VSub_DollarName lineno)} 
                      {
                        (DQ <'glob -- expected \''> ($ Id.VSub_DollarName expected) <'\', got \''> 
                          ($ Id.VSub_DollarName got) <'\''>
                        )
                      }
                    )
                  ]
                  spids: [450 465]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<alias>} {<Id.Lit_VarLike 'test_glob='> (SQ <'test_glob $LINENO'>)})
    (command.ShFunction
      name: test_case
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<typeset>} {<lineno>} {<expected>} {<subject>} {<pattern>} {<got>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'lineno='> name:lineno)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [514]
                )
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expected='> name:expected)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                  spids: [517]
                )
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subject='> name:subject)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 3)}
                  spids: [520]
                )
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'pattern='> name:pattern)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 4)}
                  spids: [523]
                )
              ]
              redirects: []
            )
            (C {<eval>} 
              {
                (DQ <'\n'> <'\t\tcase '> ($ Id.VSub_DollarName subject) <' in\n'> <'\t\t'> 
                  ($ Id.VSub_DollarName pattern) <')\tgot=\'<match>\' ;;\n'> <'\t\t*)\t\tgot=\'<nomatch>\' ;;\n'> <'\t\tesac\n'> <'\t'>
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName got)}
                              right: {(DQ ($ Id.VSub_DollarName expected))}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (C {(SQ <err_exit>)} {($ Id.VSub_DollarName lineno)} 
                      {
                        (DQ <'case '> ($ Id.VSub_DollarName subject) <' in '> 
                          ($ Id.VSub_DollarName pattern) <') -- expected \''> ($ Id.VSub_DollarName expected) <'\', got \''> ($ Id.VSub_DollarName got) <'\''>
                        )
                      }
                    )
                  ]
                  spids: [543 558]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<alias>} {<Id.Lit_VarLike 'test_case='> (SQ <'test_case $LINENO'>)})
    (C {<unset>} {<undefined>})
    (C {<export>} {<Id.Lit_VarLike 'LC_COLLATE='> <C>})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<cd>} {($ Id.VSub_DollarName tmp)})
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: (C {<err_exit>} {(DQ <'cd '> ($ Id.VSub_DollarName tmp) <' failed'>)})
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
      ]
    )
    (C {<touch>} {<B>} {<b>})
    (C {<set>} {<-->} {<Id.Lit_Star '*'>})
    (command.Case
      to_match: {($ Id.VSub_Star '*')}
      arms: [
        (case_arm
          pat_list: [{(SQ <'b B'>)}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'contrary='> name:contrary)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [650]
                )
              ]
              redirects: []
            )
          ]
          spids: [645 648 653 -1]
        )
        (case_arm
          pat_list: [{<b>} {<B>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ignorant='> name:ignorant)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [660]
                )
              ]
              redirects: []
            )
          ]
          spids: [655 658 663 -1]
        )
      ]
      redirects: []
    )
    (C {<set>} {<-->} 
      {
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: (C {<'/bin/sh'>} {<-c>} {(SQ <'echo [a-c]'>)})
          right: <Id.Eof_RParen _>
        )
      }
    )
    (command.Case
      to_match: {($ Id.VSub_Star '*')}
      arms: [
        (case_arm
          pat_list: [{<B>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'aware='> name:aware)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [690]
                )
              ]
              redirects: []
            )
          ]
          spids: [687 688 693 -1]
        )
      ]
      redirects: []
    )
    (C {<rm>} {<-rf>} {<Id.Lit_Star '*'>})
    (C {<touch>} {<a>} {<b>} {<c>} {<d>} {<abc>} {<abd>} {<abe>} {<bb>} {<bcd>} {<ca>} {<cb>} {<dd>} {<de>} 
      {<Beware>}
    )
    (C {<mkdir>} {<bdir>})
    (C {<test_glob>} {(SQ <'<a> <abc> <abd> <abe> <X*>'>)} {<a> <Id.Lit_Star '*'>} 
      {<X> <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {(SQ <'<a> <abc> <abd> <abe>'>)} 
      {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\a'> ch:a) <Id.Lit_Star '*'>}
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  child: (C {<set>} {<--nullglob>})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
              ]
            )
          action: [
            (C {<set>} {<--nullglob>})
            (C {<test_glob>} {(SQ <'<a> <abc> <abd> <abe>'>)} {<a> <Id.Lit_Star '*'>} 
              {<X> <Id.Lit_Star '*'>}
            )
            (C {<set>} {<--nonullglob>})
          ]
          spids: [761 774]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  child: (C {<set>} {<--failglob>})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
              ]
            )
          action: [
            (C {<set>} {<--failglob>})
            (C {<mkdir>} {<tmp>})
            (C {<touch>} {<'tmp/l1'>} {<'tmp/l2'>} {<'tmp/l3'>})
            (C {<test_glob>} {(SQ )} {<'tmp/l'> <Id.Lit_LBracket '['> <12> <Id.Lit_RBracket ']'>} 
              {<'tmp/'> <Id.Lit_Star '*'> <4>} {<'tmp/'> <Id.Lit_Star '*'> <3>}
            )
            (C {<test_glob>} {(SQ )} {<'tmp/l'> <Id.Lit_LBracket '['> <12> <Id.Lit_RBracket ']'>} 
              {<'tmp/'> <Id.Lit_Star '*'> <4>} {<'tmp/'> <Id.Lit_Star '*'> <3>}
            )
            (C {<rm>} {<-r>} {<tmp>})
            (C {<set>} {<--nofailglob>})
          ]
          spids: [804 817]
        )
      ]
      else_action: []
      redirects: []
    )
    (C {<test_glob>} {(SQ <'<bdir/>'>)} {<b> <Id.Lit_Star '*'> <'/'>})
    (C {<test_glob>} {(SQ <'<*>'>)} {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*')})
    (C {<test_glob>} {(SQ <'<a*>'>)} {(SQ <'a*'>)})
    (C {<test_glob>} {(SQ <'<a*>'>)} 
      {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*')}
    )
    (C {<test_glob>} {(SQ <'<c> <ca> <cb> <a*> <*q*>'>)} {<c> <Id.Lit_Star '*'>} 
      {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*')} {<Id.Lit_Star '*'> <q> <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {(SQ <'<**>'>)} {(DQ <'*'>) <Id.Lit_Star '*'>})
    (C {<test_glob>} {(SQ <'<**>'>)} 
      {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {(SQ <'<\\.\\./*/>'>)} 
      {(DQ <Id.Lit_BadBackslash '\\'> <.> <Id.Lit_BadBackslash '\\'> <'./*/'>)}
    )
    (C {<test_glob>} {(SQ <'<s/\\..*//>'>)} {(SQ <'s/\\..*//'>)})
    (C {<test_glob>} {(SQ <'</^root:/{s/^[!:]*:[!:]*:\\([!:]*\\).*$/\\1/>'>)} 
      {
        (DQ <'/^root:/{s/^[!:]*:[!:]*:'> <Id.Lit_BadBackslash '\\'> <'([!:]*'> 
          <Id.Lit_BadBackslash '\\'> <').*'>
        ) (SQ <'$'>) (DQ <'/'> <Id.Lit_BadBackslash '\\'> <'1/'>)
      }
    )
    (C {<test_glob>} {(SQ <'<abc> <abd> <abe> <bb> <cb>'>)} 
      {<Id.Lit_LBracket '['> <a-c> <Id.Lit_RBracket ']'> <b> <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {<Id.Lit_Other '+'> <Id.Lit_Other '+'> <Beware>} 
      {(SQ <'<abd> <abe> <bb> <bcd> <bdir> <ca> <cb> <dd> <de>'>)} 
      {<Id.Lit_LBracket '['> <a-y> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> <Id.Lit_LBracket '['> 
        <Id.KW_Bang '!'> <c> <Id.Lit_RBracket ']'>
      }
    )
    (C {<test_glob>} {(SQ <'<abd> <abe>'>)} 
      {<a> <Id.Lit_Star '*'> <Id.Lit_LBracket '['> <Id.KW_Bang '!'> <c> <Id.Lit_RBracket ']'>}
    )
    (C {<touch>} {<a-b>} {<aXb>})
    (C {<test_glob>} {(SQ <'<a-b> <aXb>'>)} {<Id.Lit_ArrayLhsOpen 'a['> <X-> <Id.Lit_RBracket ']'> <b>})
    (C {<touch>} {<.x>} {<.y>})
    (C {<test_glob>} {<--Beware>} {(SQ <'<Beware> <d> <dd> <de>'>)} 
      {<Id.Lit_LBracket '['> <Id.KW_Bang '!'> <a-c> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Simple
                  words: [
                    {<mkdir>}
                    {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') <b>}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
              ]
            )
          action: [
            (C {<touch>} 
              {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') <'b/ooo'>}
            )
            (C {<test_glob>} {(SQ <'<a*b/ooo>'>)} 
              {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') <'b/'> 
                <Id.Lit_Star '*'>
              }
            )
            (C {<test_glob>} {(SQ <'<a*b/ooo>'>)} 
              {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') 
                <Id.Lit_QMark '?'> <'/'> <Id.Lit_Star '*'>
              }
            )
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'!7'>)} {(SQ <'*\\!*'>)})
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'r.*'>)} {(SQ <'*.\\*'>)})
            (C {<test_glob>} {(SQ <'<abc>'>)} {<Id.Lit_ArrayLhsOpen 'a['> <b> <Id.Lit_RBracket ']'> <c>})
            (C {<test_glob>} {(SQ <'<abc>'>)} 
              {<Id.Lit_ArrayLhsOpen 'a['> (DQ <b>) <Id.Lit_RBracket ']'> <c>}
            )
            (C {<test_glob>} {(SQ <'<abc>'>)} 
              {<Id.Lit_ArrayLhsOpen 'a['> 
                (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\b'> ch:b) <Id.Lit_RBracket ']'> <c>
              }
            )
            (C {<test_glob>} {(SQ <'<abc>'>)} {<a> <Id.Lit_QMark '?'> <c>})
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'a"b"c'>)})
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'a*c'>)})
            (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'"a?c"'>)})
            (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'a\\*c'>)})
            (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'a\\[b]c'>)})
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'"$undefined"'>)} {(SQ <'""'>)})
            (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'a["\\b"]c'>)})
            (C {<rm>} {<-rf>} {<mkdir>} 
              {<a> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*') <b>}
            )
          ]
          spids: [1097 1108]
        )
      ]
      else_action: []
      redirects: []
    )
    (C {<mkdir>} {<man>})
    (C {<mkdir>} {<'man/man1'>})
    (C {<touch>} {<'man/man1/sh.1'>})
    (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
      {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
      {
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: (C {<echo>} {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>})
          right: <Id.Eof_RParen _>
        )
      }
    )
    (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
      {
        (DQ 
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            child: 
              (C {<echo>} {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>})
            right: <Id.Eof_RParen _>
          )
        )
      }
    )
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'a***c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'a*****?c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'?*****??'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'*****??'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'*****??c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'?*****?c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'?***?****c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'?***?****?'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'?***?****'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'*******c'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abc>)} {(SQ <'*******?'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a*cd**?**??k'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a**?**cd**?**??k'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a**?**cd**?**??k***'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a**?**cd**?**??***k'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a**?**cd**?**??***k**'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abcdecdhjk>)} {(SQ <'a****c**?**??*****'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'-\''>)} {(SQ <'[-abc]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'-\''>)} {(SQ <'[abc-]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} 
      {(DQ <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <'\''>)} {(SQ <'\\\\'>)}
    )
    (C {<test_case>} {(SQ <'<match>'>)} 
      {(DQ <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <'\''>)} {(SQ <'[\\\\]'>)}
    )
    (C {<test_case>} {(SQ <'<match>'>)} 
      {(DQ <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <'\''>)} {(DQ <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <'\''>)}
    )
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'[\''>)} {(SQ <'[[]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'['>)} {(SQ <'[[]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'[\''>)} {(SQ <'['>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'['>)} {(SQ <'['>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'[abc\''>)} {(DQ <'\'[\'*'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(DQ <'\'[abc\''>)} {(SQ <'[*'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'[abc'>)} {(DQ <'\'[\'*'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <'[abc'>)} {(SQ <'[*'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <abd>)} {(DQ <'a[b/c]d'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'a/d'>)} {(DQ <'a[b/c]d'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <acd>)} {(DQ <'a[b/c]d'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\']\''>)} {(SQ <'[]]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(DQ <'\'-\''>)} {(SQ <'[]-]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <p>)} {(SQ <'[a-\\z]'>)})
    (C {<test_case>} {(SQ <'<match>'>)} {(SQ <'"/tmp"'>)} {(SQ <'[/\\\\]*'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'??**********?****?'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'??**********?****c'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'?************c****?****'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'*c*?**'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'a*****c*?**'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <abc>)} {(SQ <'a********???*******'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(DQ <'\'a\''>)} {(SQ <'[]'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <a>)} {(SQ <'[]'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(DQ <'\'[\''>)} {(SQ <'[abc'>)})
    (C {<test_case>} {(SQ <'<nomatch>'>)} {(SQ <'['>)} {(SQ <'[abc'>)})
    (C {<test_glob>} {<Id.Lit_Other '+'> <Id.Lit_Other '+'> <Beware>} {(SQ <'<b> <bb> <bcd> <bdir>'>)} 
      {<b> <Id.Lit_Star '*'>}
    )
    (C {<test_glob>} {(SQ <'<Beware> <b> <bb> <bcd> <bdir>'>)} 
      {<Id.Lit_LBracket '['> <bB> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  child: (C {<set>} {<--nocaseglob>})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
              ]
            )
          action: [
            (C {<set>} {<--nocaseglob>})
            (C {<test_glob>} {(SQ <'<Beware> <b> <bb> <bcd> <bdir>'>)} {<b> <Id.Lit_Star '*'>})
            (C {<test_glob>} {(SQ <'<Beware> <b> <bb> <bcd> <bdir>'>)} 
              {<Id.Lit_LBracket '['> <b> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
            )
            (C {<test_glob>} {(SQ <'<Beware> <b> <bb> <bcd> <bdir>'>)} 
              {<Id.Lit_LBracket '['> <bB> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
            )
            (C {<set>} {<--nonocaseglob>})
          ]
          spids: [2094 2107]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  child: (C {<set>} {<-f>})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
              ]
            )
          action: [
            (C {<set>} {<-f>})
            (C {<test_glob>} {(SQ <'<*>'>)} {<Id.Lit_Star '*'>})
            (C {<set>} {<Id.Lit_Other '+'> <f>})
          ]
          spids: [2158 2171]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  child: (C {<set>} {<--noglob>})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
              ]
            )
          action: [
            (C {<set>} {<--noglob>})
            (C {<test_glob>} {(SQ <'<*>'>)} {<Id.Lit_Star '*'>})
            (C {<set>} {<--glob>})
          ]
          spids: [2198 2211]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FIGNORE='> name:FIGNORE)
          op: assign_op.Equal
          rhs: {(SQ <'.*|*'>)}
          spids: [2237]
        )
      ]
      redirects: []
    )
    (C {<test_glob>} {(SQ <'<*>'>)} {<Id.Lit_Star '*'>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FIGNORE='> name:FIGNORE)
          op: assign_op.Equal
          rhs: {(SQ <'.*|*c|*e|?'>)}
          spids: [2251]
        )
      ]
      redirects: []
    )
    (C {<test_glob>} {(SQ <'<a-b> <aXb> <abd> <bb> <bcd> <bdir> <ca> <cb> <dd> <man>'>)} 
      {<Id.Lit_Star '*'>}
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FIGNORE='> name:FIGNORE)
          op: assign_op.Equal
          rhs: {(SQ <'.*|*b|*d|?'>)}
          spids: [2265]
        )
      ]
      redirects: []
    )
    (C {<test_glob>} {(SQ <'<Beware> <abc> <abe> <bdir> <ca> <de> <man>'>)} {<Id.Lit_Star '*'>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FIGNORE='> name:FIGNORE)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [2279]
        )
      ]
      redirects: []
    )
    (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
      {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>}
    )
    (C {<unset>} {<FIGNORE>})
    (C {<test_glob>} {(SQ <'<bb> <ca> <cb> <dd> <de>'>)} {<Id.Lit_QMark '?'> <Id.Lit_QMark '?'>})
    (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
      {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>}
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'GLOBIGNORE='> name:GLOBIGNORE)
          op: assign_op.Equal
          rhs: {(SQ <'.*:*'>)}
          spids: [2320]
        )
      ]
      redirects: []
    )
    (C {<set>} {<-->} {<Id.Lit_Star '*'>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_Number 1)}
                      right: {(SQ <'*'>)}
                    )
                  redirects: []
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'GLOBIGNORE='> name:GLOBIGNORE)
                  op: assign_op.Equal
                  rhs: {(SQ <'.*:*c:*e:?'>)}
                  spids: [2348]
                )
              ]
              redirects: []
            )
            (C {<test_glob>} {(SQ <'<>'>)} {<Id.Lit_Star '*'>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'GLOBIGNORE='> name:GLOBIGNORE)
                  op: assign_op.Equal
                  rhs: {(SQ <'.*:*b:*d:?'>)}
                  spids: [2364]
                )
              ]
              redirects: []
            )
            (C {<test_glob>} {(SQ <'<>'>)} {<Id.Lit_Star '*'>})
            (C {<unset>} {<GLOBIGNORE>})
            (C {<test_glob>} {(SQ <'<>'>)} {<Id.Lit_Star '*'>})
            (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
              {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'GLOBIGNORE='> name:GLOBIGNORE)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2408]
                )
              ]
              redirects: []
            )
            (C {<test_glob>} {(SQ <'<man/man1/sh.1>'>)} 
              {<Id.Lit_Star '*'> <'/man'> <Id.Lit_Star '*'> <'/sh.'> <Id.Lit_Star '*'>}
            )
          ]
          spids: [2331 2345]
        )
      ]
      else_action: []
      redirects: []
    )
    (C {<unset>} {<GLOBIGNORE>})
    (command.ShFunction
      name: test_sub
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'x='> name:x)
                  op: assign_op.Equal
                  rhs: {(SQ <'${subject'>) ($ Id.VSub_Number 2) (SQ <'}'>)}
                  spids: [2437]
                )
              ]
              redirects: []
            )
            (C {<eval>} {<Id.Lit_VarLike 'g='> ($ Id.VSub_DollarName x)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName g))}
                              right: {(DQ ($ Id.VSub_Number 3))}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (C {(SQ <err_exit>)} {($ Id.VSub_Number 1)} 
                      {<Id.Lit_VarLike 'subject='> 
                        (DQ <'\''> ($ Id.VSub_DollarName subject) <'\' '> ($ Id.VSub_DollarName x) 
                          <' failed, expected \''> ($ Id.VSub_Number 3) <'\', got \''> ($ Id.VSub_DollarName g) <'\''>
                        )
                      }
                    )
                  ]
                  spids: [2453 2470]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<alias>} {<Id.Lit_VarLike 'test_sub='> (SQ <'test_sub $LINENO'>)})
    (C {<set>} {<--noglob>} {<--nobraceexpand>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subject='> name:subject)
          op: assign_op.Equal
          rhs: {(SQ <'A regular expressions test'>)}
          spids: [2511]
        )
      ]
      redirects: []
    )
    (C {<test_sub>} {(SQ <'/e/#'>)} {(SQ <'A r#gular expressions test'>)})
    (C {<test_sub>} {(SQ <'//e/#'>)} {(SQ <'A r#gular #xpr#ssions t#st'>)})
    (C {<test_sub>} {(SQ <'/[^e]/#'>)} {(SQ <'# regular expressions test'>)})
    (C {<test_sub>} {(SQ <'//[^e]/#'>)} {(SQ <'###e######e###e########e##'>)})
    (C {<test_sub>} {(SQ <'/+(e)/#'>)} {(SQ <'A r#gular expressions test'>)})
    (C {<test_sub>} {(SQ <'//+(e)/#'>)} {(SQ <'A r#gular #xpr#ssions t#st'>)})
    (C {<test_sub>} {(SQ <'/@-(e)/#'>)} {(SQ <'A r#gular expressions test'>)})
    (C {<test_sub>} {(SQ <'//@-(e)/#'>)} {(SQ <'A r#gular #xpr#ssions t#st'>)})
    (C {<test_sub>} {(SQ <'/?(e)/#'>)} {(SQ <'#A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'//?(e)/#'>)} {(SQ <'#A# #r#g#u#l#a#r# #x#p#r#s#s#i#o#n#s# #t#s#t#'>)})
    (C {<test_sub>} {(SQ <'/*(e)/#'>)} {(SQ <'#A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'//*(e)/#'>)} {(SQ <'#A# #r#g#u#l#a#r# #x#p#r#s#s#i#o#n#s# #t#s#t#'>)})
    (C {<test_sub>} {(SQ <'//@(e)/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//@-(e)/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//+(e)/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//+-(e)/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//@(+(e))/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//@(+-(e))/[\\1]'>)} {(SQ <'A r[e]gular [e]xpr[e]ssions t[e]st'>)})
    (C {<test_sub>} {(SQ <'//-(e)/#'>)} {(SQ <'A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'//--(e)/#'>)} {(SQ <'A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'//?(e)/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//{0,1}(e)/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//*(e)/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//{0,}(e)/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//@(?(e))/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//@({0,1}(e))/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//@(*(e))/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'//@({0,}(e))/[\\1]'>)} 
      {(SQ <'[]A[] []r[e]g[]u[]l[]a[]r[] [e]x[]p[]r[e]s[]s[]i[]o[]n[]s[] []t[e]s[]t[]'>)}
    )
    (C {<test_sub>} {(SQ <'/?-(e)/#'>)} {(SQ <'#A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'/@(?-(e))/[\\1]'>)} {(SQ <'[]A regular expressions test'>)})
    (C {<test_sub>} {(SQ <'/!(e)/#'>)} {(SQ <'#'>)})
    (C {<test_sub>} {(SQ <'//!(e)/#'>)} {(SQ <'#'>)})
    (C {<test_sub>} {(SQ <'/@(!(e))/[\\1]'>)} {(SQ <'[A regular expressions test]'>)})
    (C {<test_sub>} {(SQ <'//@(!(e))/[\\1]'>)} {(SQ <'[A regular expressions test]'>)})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subject='> name:subject)
          op: assign_op.Equal
          rhs: {(SQ <e>)}
          spids: [2858]
        )
      ]
      redirects: []
    )
    (C {<test_sub>} {(SQ <'/!(e)/#'>)} {(SQ <'#e'>)})
    (C {<test_sub>} {(SQ <'//!(e)/#'>)} {(SQ <'#e#'>)})
    (C {<test_sub>} {(SQ <'/!(e)/[\\1]'>)} {(SQ <'[]e'>)})
    (C {<test_sub>} {(SQ <'//!(e)/[\\1]'>)} {(SQ <'[]e[]'>)})
    (C {<test_sub>} {(SQ <'/@(!(e))/[\\1]'>)} {(SQ <'[]e'>)})
    (C {<test_sub>} {(SQ <'//@(!(e))/[\\1]'>)} {(SQ <'[]e[]'>)})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subject='> name:subject)
          op: assign_op.Equal
          rhs: {(SQ <a>)}
          spids: [2925]
        )
      ]
      redirects: []
    )
    (C {<test_sub>} {(SQ <'/@(!(a))/[\\1]'>)} {(SQ <'[]a'>)})
    (C {<test_sub>} {(SQ <'//@(!(a))/[\\1]'>)} {(SQ <'[]a[]'>)})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subject='> name:subject)
          op: assign_op.Equal
          rhs: {(SQ <aha>)}
          spids: [2952]
        )
      ]
      redirects: []
    )
    (C {<test_sub>} {(SQ <'/@(!(a))/[\\1]'>)} {(SQ <'[aha]'>)})
    (C {<test_sub>} {(SQ <'//@(!(a))/[\\1]'>)} {(SQ <'[aha]'>)})
    (C {<test_sub>} {(SQ <'/@(!(aha))/[\\1]'>)} {(SQ <'[ah]a'>)})
    (C {<test_sub>} {(SQ <'//@(!(aha))/[\\1]'>)} {(SQ <'[ah][a]'>)})
    (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{($ Id.VSub_DollarName errors)})
  ]
)