(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TMP)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name TMP>
                suffix_op: 
                  (suffix_op.Unary
                    tok: <Id.VTest_ColonHyphen ':-'>
                    arg_word: {<Id.Lit_Slash '/'> <tmp>}
                  )
              )
            }
          spids: [40]
        )
      ]
    )
    (C {<readonly>} {<TMP>})
    (command.ShFunction
      name: log
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_Number '$0') <': '> ($ Id.VSub_At '$@'))}]
              redirects: [(redir op:<Id.Redir_GreatAnd '1>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: die
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_Number '$0') <' ERROR: '> ($ Id.VSub_At '$@'))}]
              redirects: [(redir op:<Id.Redir_GreatAnd '1>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: show_help
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 127
                      stdin_parts: [
                        <'Usage: ./configure [OPTION]\n'>
                        <'\n'>
                        <'Detects system settings before a build of Oil.\n'>
                        <'\n'>
                        <'  --prefix            Prefix for the bin/ directory [/usr/local]\n'>
                        <'  --with-readline     Fail unless readline is available.\n'>
                        <
'  --without-readline  Don\'t compile with readline, even if it\'s available.\n'
                        >
                        <'\t\t      The shell won\'t have any interactive features.\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:FLAG_prefix)
          op: assign_op.Equal
          rhs: {(SQ <'/usr/local'>)}
          spids: [140]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:FLAG_with_readline)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [145]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:FLAG_without_readline)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [152]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [(command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [177 179 185 -1]
                )
                (case_arm
                  pat_list: [{<--help>}]
                  action: [
                    (C {<show_help>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [188 189 204 -1]
                )
                (case_arm
                  pat_list: [{<--with-readline>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:FLAG_with_readline)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [212]
                        )
                      ]
                    )
                  ]
                  spids: [208 209 216 -1]
                )
                (case_arm
                  pat_list: [{<--without-readline>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:FLAG_without_readline)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [224]
                        )
                      ]
                    )
                  ]
                  spids: [220 221 228 -1]
                )
                (case_arm
                  pat_list: [{<--prefix> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:FLAG_prefix)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<expr>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Colon ':'>} 
                                    {(SQ <'--prefix=\\(.*\\)'>)}
                                  )
                              )
                            }
                          spids: [246]
                        )
                      ]
                    )
                  ]
                  spids: [240 243 262 -1]
                )
                (case_arm
                  pat_list: [{<--prefix>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<test>} {($ Id.VSub_Pound '$#')} {<-eq>} {<1>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<die>} {(DQ <'--prefix requires an argument'>)})]
                          spids: [269 280]
                        )
                      ]
                    )
                    (C {<shift>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:FLAG_prefix)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [296]
                        )
                      ]
                    )
                  ]
                  spids: [265 266 300 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<die>} {(DQ <'Invalid argument \''> ($ Id.VSub_Number '$1') <'\''>)})]
                  spids: [303 304 316 -1]
                )
              ]
            )
            (C {<shift>})
          ]
        )
    )
    (command.ShFunction
      name: cc_quiet
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<cc>} {(DQ ($ Id.VSub_At '$@'))} {<-o>} {<'/dev/null'>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
                (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: cc_or_die
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [{<cc>} {(DQ ($ Id.VSub_At '$@'))}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {($ Id.VSub_DollarName '$TMP') <'/cc.log'>}
                                    )
                                    (redir
                                      op: <Id.Redir_GreatAnd '2>&'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<1>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<log>} {(DQ <'Error running \'cc '> ($ Id.VSub_At '$@') <'\':'>)})
                    (C {<cat>} {($ Id.VSub_DollarName '$TMP') <'/cc.log'>})
                    (C {<die>} {(DQ <'Fatal compile error running feature test'>)})
                  ]
                  spids: [366 384]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: cc_statement
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'pp_var='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<Id.Lit_VarLike 'prog='> (DQ ($ Id.VSub_Number '$2'))})
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$TMP') <'/cc_statement.c'>}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 456
                      stdin_parts: [
                        <'int main() {\n'>
                        <'  '>
                        ($ Id.VSub_DollarName '$prog')
                        <'\n'>
                        <'}\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<cc_quiet>} {($ Id.VSub_DollarName '$TMP') <'/cc_statement.c'>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {(DQ <'#define '> ($ Id.VSub_DollarName '$pp_var') <' 1'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [462 470]
                )
              ]
              else_action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
            )
          ]
        )
    )
    (command.ShFunction
      name: detect_readline
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<cc_quiet>} {<'build/detect-readline.c'>} {<-l>} {<readline>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<echo>} {(SQ <'HAVE_READLINE=1'>)})]
                  spids: [510 521]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$FLAG_with_readline'))} 
                                  {<Id.Lit_Equals '='>} {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (C {<die>} 
                          {(SQ <'readline was not detected on the system (--with-readline passed).'>)}
                        )
                      ]
                      spids: [534 547]
                    )
                  ]
                )
                (C {<echo>} {(SQ <'HAVE_READLINE='>)})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: detect_and_echo_vars
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<test>} {(DQ ($ Id.VSub_DollarName '$FLAG_without_readline'))} 
                              {<Id.Lit_Equals '='>} {<1>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<echo>} {(SQ <'HAVE_READLINE='>)})]
                  spids: [579 592]
                )
              ]
              else_action: [(C {<detect_readline>})]
            )
            (C {<echo>} {(DQ <'PREFIX='> ($ Id.VSub_DollarName '$FLAG_prefix'))})
          ]
        )
    )
    (command.ShFunction
      name: cc_print_expr
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'c_expr='> (DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$TMP') <'/print_expr.c'>}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 661
                      stdin_parts: [
                        <'#include <stdio.h>\n'>
                        <'#include <sys/types.h>  /* size_t, pid_t */\n'>
                        <'\n'>
                        <'int main() {\n'>
                        <'  printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'%lu'>
                        <Id.Right_DoubleQuote '"'>
                        <', '>
                        ($ Id.VSub_DollarName '$c_expr')
                        <');\n'>
                        <'}\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (C {<cc_or_die>} {<-o>} {($ Id.VSub_DollarName '$TMP') <'/print_expr'>} 
              {($ Id.VSub_DollarName '$TMP') <'/print_expr.c'>}
            )
            (command.Simple
              words: [{($ Id.VSub_DollarName '$TMP') <'/print_expr'>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$TMP') <'/print_expr.out'>}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: check_sizeof
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'pp_var='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<Id.Lit_VarLike 'c_type='> (DQ ($ Id.VSub_Number '$2'))})
            (C {<local>} {<Id.Lit_VarLike 'min_bytes='> (DQ ($ Id.VSub_Number '$3'))})
            (C {<cc_print_expr>} {(DQ <'sizeof('> ($ Id.VSub_DollarName '$c_type') <')'>)})
            (C {<local>} {<actual_bytes>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:actual_bytes)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<cat>} {($ Id.VSub_DollarName '$TMP') <'/print_expr.out'>})
                      )
                    }
                  spids: [771]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$min_bytes'))})
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$actual_bytes'))} {<-lt>} 
                                  {(DQ ($ Id.VSub_DollarName '$min_bytes'))}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ <'sizeof('> ($ Id.VSub_DollarName '$c_type') <') should be at least '> 
                          ($ Id.VSub_DollarName '$min_bytes') <'; got '> ($ Id.VSub_DollarName '$actual_bytes')
                        )
                      }
                    )
                  ]
                  spids: [781 806]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ <'#define '> ($ Id.VSub_DollarName '$pp_var') <' '> 
                  ($ Id.VSub_DollarName '$actual_bytes')
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: detect_c_language
      body: 
        (BraceGroup
          children: [
            (C {<check_sizeof>} {<SIZEOF_INT>} {(SQ <int>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_LONG>} {(SQ <long>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_VOID_P>} {(SQ <'void *'>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_SHORT>} {(SQ <short>)} {<2>})
            (C {<check_sizeof>} {<SIZEOF_FLOAT>} {(SQ <float>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_DOUBLE>} {(SQ <double>)} {<8>})
            (C {<check_sizeof>} {<SIZEOF_SIZE_T>} {(SQ <size_t>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_FPOS_T>} {(SQ <fpos_t>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_PID_T>} {(SQ <pid_t>)} {<4>})
            (C {<check_sizeof>} {<SIZEOF_OFF_T>} {(SQ <off_t>)} {(SQ )})
            (C {<check_sizeof>} {<SIZEOF_TIME_T>} {(SQ <time_t>)} {(SQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<cc_statement>} {<HAVE_LONG_LONG>} {(SQ <'long long x; x = (long long)0;'>)})
                      ]
                    )
                  action: [(C {<check_sizeof>} {<SIZEOF_LONG_LONG>} {(SQ <'long long'>)} {<8>})]
                  spids: [995 1006]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<cc_statement>} {<HAVE_LONG_DOUBLE>} 
                          {(SQ <'long double x; x = (long double)0;'>)}
                        )
                      ]
                    )
                  action: [(C {<check_sizeof>} {<SIZEOF_LONG_DOUBLE>} {(SQ <'long double'>)} {<8>})]
                  spids: [1023 1034]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<cc_statement>} {<HAVE_C99_BOOL>} {(SQ <'_Bool x; x = (_Bool)0;'>)})
                      ]
                    )
                  action: [(C {<check_sizeof>} {<SIZEOF__BOOL>} {(SQ <_Bool>)} {<1>})]
                  spids: [1052 1063]
                )
              ]
            )
            (C {<echo>} {(SQ <'#define HAVE_WCHAR_H 1'>)})
            (C {<echo>} {(SQ <'#define SIZEOF_WCHAR_T 4'>)})
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$TMP') <'/detect_va_list.c'>}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 1144
                      stdin_parts: [
                        <'#include <stdarg.h>  /* C89 */\n'>
                        <'int main() {\n'>
                        <'  va_list list1, list2;\n'>
                        <'  list1 = list2;\n'>
                        <'}\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<cc_quiet>} {($ Id.VSub_DollarName '$TMP') <'/detect_va_list.c'>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<echo>} {(SQ )})]
                  spids: [1146 1154]
                )
              ]
              else_action: [(C {<echo>} {(SQ <'#define VA_LIST_IS_ARRAY 1'>)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: main
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [(C {<cc_quiet>} {<'build/detect-cc.c'>})]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<die>} {(DQ <'Couldn\'t compile a basic C program (cc not installed?)'>)})
                  ]
                  spids: [1197 1206]
                )
              ]
            )
            (C {<mkdir>} {<-p>} {<_build>})
            (C {<local>} {<Id.Lit_VarLike 'sh_out='> <'_build/detected-config.sh'>})
            (C {<local>} {<Id.Lit_VarLike 'c_out='> <'_build/detected-config.h'>})
            (command.Simple
              words: [{<detect_and_echo_vars>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$sh_out')}
                )
              ]
              do_fork: T
            )
            (command.Simple
              words: [{<detect_c_language>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$c_out')}
                )
              ]
              do_fork: T
            )
            (C {<log>} 
              {
                (DQ <'Wrote '> ($ Id.VSub_DollarName '$sh_out') <' and '> 
                  ($ Id.VSub_DollarName '$c_out')
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: unittest
      body: 
        (BraceGroup
          children: [
            (C {<cc_print_expr>} {(SQ <'sizeof(int)'>)})
            (C {<local>} {<actual>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:actual)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<cat>} {($ Id.VSub_DollarName '$TMP') <'/print_expr.out'>})
                      )
                    }
                  spids: [1294]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$actual'))} {<Id.Lit_Equals '='>} {<4>})
                (C {<die>} {(DQ <'Expected 4, got '> ($ Id.VSub_DollarName '$actual'))})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<check_sizeof>} {<SIZEOF_INT>} {(SQ <int>)} {<4>})
                (C {<die>} {(DQ <FAILED>)})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<cc_statement>} {<HAVE_INT>} {(SQ <'int x = (int)0;'>)})
                (C {<die>} {(DQ <FAILED>)})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<cc_statement>} {<HAVE_FOO>} {(SQ <'foo x = (foo)0;'>)})
                (C {<die>} {(DQ <'Expected to fail'>)})
              ]
            )
          ]
        )
    )
    (C {<main>} {(DQ ($ Id.VSub_At '$@'))})
  ]
)